e#]c@sdZddlZddlZddlZddlZddlmZmZm Z ddl Zddl m Z ddlZejeZdejfdYZdejfdYZd ejfd YZd ejfd YZd eejefdYZdefdYZdee jfdYZdejefdYZdejfdYZdefdYZ de fdYZ!de fdYZ"deejefdYZ#dS(sThis module contains support classes from which schema-specific bindings inherit, and that describe the content models of those schema.iN(tdomutilstutilitytsix(tXMLSchema_instancet_TypeBinding_mixinc Bs'eZejZedZedZdZdZ e e Z edZ dZ d4Zd4Zedddd d gZejrd Znd5ZeZdZdZd4ZdZdZd4Zd4ZdZe dZ!edZ"eZ#dZ$dZ%eZ&d Z'ed!Z(d"Z)ed#Z*d$Z+ed%Z,ed&Z-ed'Z.ed(Z/d4Z0iZ1ed)Z2d*Z3d4d4d4d+Z4d4d4ed4d,Z5d-Z6d.Z7d/Z8d0Z9d1Z:ed2Z;d3Z<RS(6cCs ||_dS(s0Set the validation configuration for this class.N(t_validationConfig_(tclstvalidation_config((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_SetValidationConfig%scCs|jS(sThe L{pyxb.ValidationConfig} instance that applies to this class. By default this will reference L{pyxb.GlobalValidationConfig}.(R(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_GetValidationConfig*scCs ||_dS(s3Set the validation configuration for this instance.N(R(tselfR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_setValidationConfig1scCs|jS(sThe L{pyxb.ValidationConfig} instance that applies to this instance. By default this will reference the class value from L{_GetValidationConfig}, which defaults to L{pyxb.GlobalValidationConfig}.(R(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt__getValidationConfig5scCs|j}|jo|jS(sDetermine whether the content model should be validated for this class. In the absence of context, this returns C{True} iff both binding and document validation are in force. @deprecated: use L{_GetValidationConfig} and check specific requirements.(Rt forBindingt forDocument(Rtvo((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_PerformValidation@s cCs|j}|jo|jS(sDetermine whether the content model should be validated for this instance. In the absence of context, this returns C{True} iff both binding and document validation are in force. @deprecated: use L{_validationConfig} and check specific requirements.(t_validationConfigR R(R R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_performValidationLs tvalidateBindingttoDOMttoxmltFactorytpropertycCs=||jkr$tj||ntt|j||S(N(t_ReservedSymbolstpyxbtReservedNameErrortsuperRt __setattr__(R tnametvalue((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR`st _dom_nodet_fallback_namespacet _from_xmlt_apply_whitespace_facett_validate_constraintst_require_valuet_nilt_elementt_apply_attributest_convert_string_valuest _locationcCs|jS(s.Return a L{namespace context } associated with the binding instance. This will return C{None} unless something has provided a context to the instance. Context is provided when instances are generated by the DOM and SAX-based translators.(t$_TypeBinding_mixin__namespaceContext(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_namespaceContextrscCs ||_|S(scAssociate a L{namespace context } with the binding instance.(R*(R tnamespace_context((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_setNamespaceContextzs cCs:ddl}|dks-t|ts-t||_|S(sAssociate an element binding with the instance. Since the value of a binding instance reflects only its content, an associated element is necessary to generate an XML document or DOM tree. @param elt: the L{pyxb.binding.basis.element} instance associated with the value. This may be C{None} when disassociating a value from a specific element.iN(tpyxb.binding.contenttNonet isinstancetelementtAssertionErrort_TypeBinding_mixin__element(R teltR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt _setElements ! cCs|jS(s Return a L{pyxb.binding.basis.element} associated with the binding instance. This will return C{None} unless an element has been associated. Constructing a binding instance using the element instance will add this association. (R3(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR&scCs|jS(sOIndicate whether this instance is U{nil }. The value is set by the DOM and SAX parsers when building an instance from a DOM element with U{xsi:nil } set to C{true}. @return: C{None} if the element used to create the instance is not U{nillable}. If it is nillable, returns C{True} or C{False} depending on whether the instance itself is U{nil}. (t_TypeBinding_mixin__xsiNil(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_isNils cCsL|jdkr!tj|n| |_|jrH|jdtndS(s^Set the xsi:nil property of the instance. @param nil: C{True} if the value of xsi:nil should be C{true}, C{False} if the value of xsi:nil should be C{false}. @raise pyxb.NoNillableSupportError: the instance is not associated with an element that is L{nillable }. treset_elementsN(R6R/RtNoNillableSupportErrort _resetContenttTrue(R tnil((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt _setIsNils   cCsdS(sEReset the content of an element value. This is not a public method. For simple types, this does nothing. For complex types, this clears the L{content} array, removing all non-element content from the instance. It optionally also removes all element content. @param reset_elements: If C{False} (default) only the content array is cleared, which has the effect of removing any preference for element order when generating a document. If C{True}, the element content stored within the binding is also cleared, leaving it with no content at all. @note: This is not the same thing as L{complexTypeDefinition.reset}, which unconditionally resets attributes and element and non-element content. N((R R8((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR:scCskdt|k|_|jrC|jrgtj||dqgn$tt|tjrgt |_ndS(Ni( tlent(_TypeBinding_mixin__constructedWithValueR6RtContentInNilInstanceErrort issubclassttypeRt string_typesR;(R targs((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt__checkNilCtors   cCs|jS(N(R?(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_constructedWithValuescOs|jdd}|jdt}tt|j|||dksU|jra||_n|dk r}|j|n|j |dS(NR&R%( tpopR/tFalseRRt__init__tnillableR6R5t _TypeBinding_mixin__checkNilCtor(R RDtkwR1tis_nil((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRIs  cCsdS(sMethod invoked upon entry to the Factory method. This method is entitled to modify the keywords array. It can also return a state value which is passed to _postFactory_vx.N(R/(RRDRL((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_PreFactory_vxscCsdS(sMethod invoked prior to leaving the Factory method. This is an instance method, and is given the state that was returned by _PreFactory_vx.N(R/(Rtstate((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_postFactory_vxscOs|jd}|jd}|dkrKt|tjrK|j}n|jd|dk |j}|j||}|j ||}|j ||jdkr|dk r|j |n|S(sProvide a common mechanism to create new instances of this type. The class constructor won't do, because you can't create instances of union types. This method may be overridden in subclasses (like STD_union). Pre- and post-creation actions can be customized on a per-class instance by overriding the L{_PreFactory_vx} and L{_postFactory_vx} methods. @keyword _dom_node: If provided, the value must be a DOM node, the content of which will be used to set the value of the instance. @keyword _location: An optional instance of L{pyxb.utils.utility.Location} showing the origin the binding. If C{None}, a value from C{_dom_node} is used if available. @keyword _from_xml: If C{True}, the input must be either a DOM node or a unicode string comprising a lexical representation of a value. This is a further control on C{_apply_whitespace_facet} and arises from cases where the lexical and value representations cannot be distinguished by type. The default value is C{True} iff C{_dom_node} is not C{None}. @keyword _apply_whitespace_facet: If C{True} and this is a simpleTypeDefinition with a whiteSpace facet, the first argument will be normalized in accordance with that facet prior to invoking the parent constructor. The value is always C{True} if text content is extracted from a C{_dom_node}, and otherwise defaults to the defaulted value of C{_from_xml}. @keyword _validate_constraints: If C{True}, any constructed value is checked against constraints applied to the union as well as the member type. @keyword _require_value: If C{False} (default), it is permitted to create a value without an initial value. If C{True} and no initial value was provided, causes L{pyxb.SimpleContentAbsentError} to be raised. Only applies to simpleTypeDefinition instances; this is used when creating values from DOM nodes. RR)R!N( tgetR/R0RtLocatable_mixinR)t setdefaultt_SupersedingClassRNt_DynamicCreateRPt _setLocation(RRDRLtdom_nodetlocationtused_clsROtrv((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs,  cCs5|dks|jdkr"tS|jj|S(N(R/R&RHtsubstitutesFor(R R1((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_substitutesFor8scCstS(sReturn C{True} iff this is the ur-type. The only ur-type is {http://www.w3.org/2001/XMLSchema}anyType. The implementation of this method is overridden for L{pyxb.binding.datatypes.anyType}.(RH(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt _IsUrType=scCs|jr||kS|jr/||jkSt|trx-|jD]"}t||rH|j|SqHWtjd||fn||jkS(Ns5Union %s instance type %s not sublass of member type?( R]t _AbstractRTRAt STD_uniont _MemberTypest_RequireXSITypeRt LogicError(Rt value_typetmt((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRaFs   c Ks|jdt}|dkr"dSt||r5|St|}tjrbt|krbtj}nt ||r{||St|t rt |tj r||St|t rt |t jjjr||S|r|tjkr||St |tr:x2|jD]$}y|j||SWqqXqWnt jjj|krbt |trb|St jjj|krt|tstjd|jt|||}n|St|t jr|j|j|S|jrj|j|}t|tr||kr|St|tj rBt|t|krB|St|t!rj|j"|krj|Snt j#||dS(szReturn a variant of the value that is compatible with this type. Compatibility is defined relative to the type definition associated with the element. The value C{None} is always compatible. If C{value} has a Python type (e.g., C{int}) that is a superclass of the required L{_TypeBinding_mixin} class (e.g., C{xs:byte}), C{value} is used as a constructor parameter to return a new instance of the required type. Note that constraining facets are applied here if necessary (e.g., although a Python C{int} with value C{500} is type-compatible with C{xs:byte}, it is outside the value space, and compatibility will fail). @keyword _convert_string_values: If C{True} (default) and the incoming value is a string, an attempt will be made to form a compatible value by using the string as a constructor argument to the this class. This flag is set to C{False} when testing automaton transitions. @raise pyxb.SimpleTypeValueError: if the value is not both type-consistent and value-consistent with the element's type. R(s)Created %s instance from value of type %sN($RQR;R/R0RBRtPY2tstrt text_typeRAtintt long_typetboolRtbindingt datatypestbooleanR_R`t_CompatibleValuet anySimpleTypetsimpleTypeDefinitiontanyTypeRt_logtinfot _ExpandedNametBINDtcreateInstanceRt_IsSimpleTypeContenttdecimaltDecimaltcomplexTypeDefinitionRtSimpleTypeValueError(RRRLtconvert_string_valuesRcRdRZ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRn[sP    ! '   $ *!cCstjddS(sReturn True iff the content of this binding object is a simple type. This is true only for descendents of simpleTypeDefinition and instances of complexTypeDefinition that have simple type content.s:Failed to override _TypeBinding_mixin._IsSimpleTypeContentN(RRb(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRwscCsi}xrtd|jjD][}|jj|}tjj|}|jtjjtfkrjqn|j |||||jq>Wx-tj |D]\}}|j ||qWdS(sInvoke self._setAttribute based on node attributes and keywords. Though attributes can only legally appear in complexTypeDefinition instances, delayed conditional validation requires caching them in simpleTypeDefinition. @param kw: keywords passed to the constructor. This map is mutated by the call: keywords corresponding to recognized attributes are removed. @param dom_node: an xml.dom Node instance, possibly C{None} N( R/tupdatet%_TypeBinding_mixin__AttributesFromDOMRt itervaluest _AttributeMapRGtidRt iteritemst _setAttribute(R RLRWRtfutivRt value_lex((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt _setAttributesFromKeywordsAndDOMs  cCs'|dkrtj}n|j}t|tjrWtjj |j |}n|dkr|j dk r|j }|j }|p|j jt|}n|dkrtj|n|j||}|r|j|tj|jn|j|||j|jS(sHConvert this instance to a DOM node. The name of the top-level element is either the name of the L{element} instance associated with this instance, or the XML name of the type of this instance. @param bds: Support for customizing the generated document @type bds: L{pyxb.utils.domutils.BindingDOMSupport} @param parent: If C{None}, a standalone document is created; otherwise, the created element is a child of the given element. @type parent: C{xml.dom.Element} or C{None} @rtype: C{xml.dom.Document} N(R/RtBindingDOMSupporttrequireXSITypeR0RRCRRRtdefaultNamespaceR&RttypeDefinitionRaRBtUnboundElementErrortcreateChildElementt addAttributeRRtt _toDOM_csctfinalizetdocument(R tbdstparentt element_namet need_xsi_typetelement_bindingR1((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs"    $  cCs4|j|d|}|r'|j}n|j|S(sShorthand to get the object as an XML document. If you want to set the default namespace, pass in a pre-configured C{bds}. @param encoding: The encoding to be used. See @C{xml.dom.Node.toxml()} for a description of why you should always pass @C{'utf-8'} here. Because this method follows the contract of the corresponding C{xml.dom.Node} method, it does not automatically get the default PyXB output encoding. @param bds: Optional L{pyxb.utils.domutils.BindingDOMSupport} instance to use for creation. If not provided (default), a new generic one is created. @param root_only: Set to C{True} to automatically deference the C{documentElement} of the resulting DOM node. This eliminates the XML declaration that would otherwise be generated. @param element_name: This value is passed through to L{toDOM}, and is useful when the value has no bound element but you want to convert it to XML anyway. R(RtdocumentElementR(R tencodingRt root_onlyRtdom((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs cs_|dk st|jr4j|tjdnttt|dfd|S(NttrueRcsS(N((t_argst_kw(t dom_support(sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt9s( R/R2R6RRR<tgetattrRR(R RR((RsG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR5s cCs tdt|jfdS(s9Override in subclasses for type-specific validation of instance content. @return: C{True} if the instance validates @raise pyxb.BatchContentValidationError: complex content does not match model @raise pyxb.SimpleTypeValueError: simple content fails to satisfy constraints s%s._validateBinding_vxN(tNotImplementedErrorRBt__name__(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_validateBinding_vx;scCs|jr|jntS(s0Check whether the binding content matches its content model. @return: C{True} if validation succeeds. @raise pyxb.BatchContentValidationError: complex content does not match model @raise pyxb.SimpleTypeValueError: attribute or simple content fails to satisfy constraints (RRR;(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyREs  cCs|S(sInform content model that all additions have been provided. This is used to resolve any pending non-determinism when the content of an element is provided through a DOM assignment or through positional arguments in a constructor.((R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_finalizeContentModelPscCs|j|S(N(R(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_postDOMValidateXs cCs,|jdk rtj|jStj|S(sReturn the best descriptive name for the type of the instance. This is intended to be a human-readable value used in diagnostics, and is the expanded name if the type has one, or the Python type name if it does not.N(RtR/RRg(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_Name\scCs/|jdkr|jStj|jjS(sThe best name available for this instance in diagnostics. If the instance is associated with an element, it is the element name; otherwise it is the best name for the type of the instance per L{_Name}.N(R3R/RRRgR(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_diagnosticNamegs N( s _dom_nodes_fallback_namespaces _from_xmlR"s_validate_constraintss_require_values_nils_elements_apply_attributess_convert_string_valuess _location(=Rt __module__RtGlobalValidationConfigRt classmethodRR R t'_TypeBinding_mixin__getValidationConfigRRRRR/Rtt _XSDLocationtsetRt_CorruptionDetectionEnabledRt_PyXBFactoryKeywordsRHR^R+R-R*R5R&R3R6R7R;R=R:R?RKRFt-_TypeBinding_mixin__WarnedUnassociatedElementRIRNRPRR\R]RaRnRwt_AttributeWildcardRRRRRRRRRRRR(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRsl                9  c  !    t_DynamicCreate_mixincBsweZdZedZedZedZedZedZedZ edZ RS(sHelper to allow overriding the implementation class. Generally we'll want to augment the generated bindings by subclassing them, and adding functionality to the subclass. This mix-in provides a way to communicate the existence of the superseding subclass back to the binding infrastructure, so that when it creates an instance it uses the subclass rather than the unaugmented binding class. When a raw generated binding is subclassed, L{_SetSupersedingClass} should be invoked on the raw class passing in the superseding subclass. E.g.:: class mywsdl (raw.wsdl): pass raw.wsdl._SetSupersedingClass(mywsdl) cCsd|jfS(Ns_%s__SupersedingClass(R(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt__SupersedingClassAttributescCsd|jfS(Ns_%s__AlternativeConstructor(R(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt!__AlternativeConstructorAttributescCst||j|S(s9Return the class stored in the class reference attribute.(Rt/_DynamicCreate_mixin__SupersedingClassAttribute(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRTscCs8t||jd}t|tr4|d}n|S(s9Return the class stored in the class reference attribute.iN(Rt5_DynamicCreate_mixin__AlternativeConstructorAttributeR/R0ttuple(RRZ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_AlternativeConstructors cCsc|dks!t||s!t|dkrI|jj|jdnt||j||S(sySet the class reference attribute. @param superseding: A Python class that is a subclass of this class. N(R/RAR2t__dict__RGRtsetattr(Rt superseding((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_SetSupersedingClasss ! cCs]|j}|dkr.|jj|dnt|||f|j|ksYt|S(N(RR/RRGRRR2(Rtalternative_constructorR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_SetAlternativeConstructors   cOsb|j}|dkr'|j}ny|||SWn#tk r]tj||nXdS(sDInvoke the constructor for this class or the one that supersedes it.N(RR/RTt TypeErrorRR{(RRDRLtctor((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRUs   ( RRt__doc__RRRRTRRRRU(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRps  t_RepresentAsXsdLiteral_mixincBseZdZRS(s Marker class for data types using XSD literal string as pythonLiteral. This is necessary for any simple data type where Python repr() produces a constructor call involving a class that may not be available by that name; e.g. duration, decimal, and any of the date/time types.(RRR(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRst_NoNullaryNonNillableNew_mixincBseZdZRS(sMarker class indicating that a simple data type cannot construct a value from XML through an empty string. This class should appear immediately L{simpleTypeDefinition} (or whatever inherits from L{simpleTypeDefinition} in cases where it applies.(RRR(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRsRpc BseZdZiZejjeddddddddd d d g ZiZe d Z e d Z e dZ e dZ e dZdZdZe dZe dZe dZe dZdZe dZe dZiZe d)dZd)dZdZe dZdZe dZd Z d!Z!e d"Z"e d#Z#e d$Z$d%Z%d&Z&d'Z'e e(e)d(Z*RS(*sL{simpleTypeDefinition} is a base class that is part of the hierarchy of any class that represents the Python datatype for a L{SimpleTypeDefinition}. @note: This class, or a descendent of it, must be the first class in the method resolution order when a subclass has multiple parents. Otherwise, constructor keyword arguments may not be removed before passing them on to Python classes that do not accept them. t XsdLiteralt xsdLiteralt XsdSuperTypet XsdPythonTypetXsdConstraintsOKtxsdConstraintsOKtXsdValueLengthtxsdValueLengtht PythonLiteralt pythonLiteraltSimpleTypeDefinitioncCs|jj|}|dkr|j}|jdrC|d7}n|tkr_d|f}nJd}y|jj}Wntk rnXdt j d||f}||j|R0RRCRRgtnormalizeStringR( RRDRLRWtfrom_xmlt text_contenttapply_whitespace_facett cf_whitespacetnorm_str((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_ConvertArgumentsVs   .  cOs|jdd|jdd|jdd|jdd|jdd|jdd}|j||}|jdt}dt|kr|r| rt|trtj||n|jd dt|t st yEt t |}|j tj kr|j |S|j |||SWnEtk rXtj||n#tk rztj||nXdS( NR#R$R&R R'R%R!iR)(RGR/RRHR>RARRR{RR2RRpt__new__tobjectt ValueErrort OverflowError(RRDRLRMRR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRzs0   cOsw|jd|jj}|jdt}|jd}|jd}|dkrut|tjru|j }n|jdt }|j ||}yt t |j||Wn)tk rtjt||nX|r|dk r|j||n|rJ|j rJ|dkr5|j }ntj||n|rs|jdt rs|j|ndS(sInitialize a newly created STD instance. Usually there is one positional argument, which is a value that can be converted to the underlying Python type. @keyword _validate_constraints: If True (default if validation is enabled), the newly constructed value is checked against its constraining facets. @type _validate_constraints: C{bool} @keyword _apply_attributes: If C{True} (default), any attributes present in the keywords or DOM node are applied. Normally presence of such an attribute should produce an error; when creating simple content for a complex type we need the DOM node, but do not want to apply the attributes, so we bypass the application. R#R$RR)R'R%N(RGRR RHRQR/R0RRRR)R;RRRpRIRRR{RBRRFtSimpleContentAbsentErrorR(R RDRLtvalidate_constraintst require_valueRWRXtapply_attributes((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRIs(  cCsd|jfS(Ns_%s__SimpleTypeDefinition(R(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt __STDAttrNamescCsx|j}t||rdt||}||krdtjd||j|jfqdnt|||dS(shSet the L{pyxb.xmlschema.structures.SimpleTypeDefinition} instance associated with this binding.s/%s: Attempt to override existing STD %s with %sN(t"_simpleTypeDefinition__STDAttrNamethasattrRRRbRR(Rtstdt attr_namet old_value((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_SimpleTypeDefinitions   .cCs.|j}t||s!tt||S(sReturn the SimpleTypeDefinition instance for the given class. This should only be invoked when generating bindings. An STD must have been associated with the class using L{_SimpleTypeDefinition}.(RRR2R(RR ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs cCstjd|fdS(sConvert from a python value to a string usable in an XML document. This should be implemented in the subclass.s %s does not implement XsdLiteralN(RRb(RR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRscCs|jrdS|j|S(sReturn text suitable for representing the value of this instance in an XML document. The base class implementation delegates to the object class's XsdLiteral method.R(R7R(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs cCsixL|jD]>}||kr%q nt|kr8|jSt|tr |Sq Wtjd|fdS(sFind the nearest parent class in the PST hierarchy. The value for anySimpleType is None; for all others, it's a primitive or derived PST descendent (including anySimpleType).sNo supertype found for %sN(RRpt _XsdBaseTypeRARRb(Rtsc((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs  cs.ttt|dfd}|S(s Pre-extended class method to verify other things before checking constraints. This is used for list types, to verify that the values in the list are acceptable, and for token descendents, to check the lexical/value space conformance of the input. t_XsdConstraintsPreCheck_vbcsS(N((taRL(R(sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs(RRRp(RRtsuper_fn((RsG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs $c CsF|j|}|jj|}|dkrg|jD]}t|tr:|^q:}|jt}g}xz|D]r}yt t j |j }Wnt k rt}g}nXx*|D]"} | |kr|j| qqWqxW|r||j|t_ValidatedMemberRR{R;R`RRRRRPR-( RRDRLRYRORZRtargRdRX((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs@        cCsyt||jsuxK|jD]@}y|j|dt}|SWqttjfk r[qXqWtj||n|S(sValidate the given value as a potential union member. @raise pyxb.SimpleTypeValueError: the value is not an instance of a member type.R#(R0R`RR;RRR{R-(RRRd((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR:scOs tjd|jjfdS(Ns'%s: cannot construct instances of union(RRbt __class__R(R RDRL((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRscOs tjd|jjfdS(Ns'%s: cannot construct instances of union(RRbR<R(R RDRL((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRIscCsg|j}|r|S|dg}|jdjg|jD]}|jdt^q8dj|S(Ns , union of s, R1R(RRR5R`R2R;(RR1R6RR7t_td((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR2s   8cCs|j|jS(sCConvert from a binding value to a string usable in an XML document.(R:R(RR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRsN(RRRR/R`t_STD_union__FacetMapRRR:RRIRHR;R2R(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR_s 2  R(cBseZdZdZiZeddZedZedZ edZ ee e dZ edZdZdZejrd Znd Zd Ze d Zd ZdZdZdZRS(sBase class for collection datatypes. This class descends from the Python list type, and incorporates simpleTypeDefinition. Subclasses must define a class variable _ItemType which is a reference to the class of which members must be instances.cCst||jrnt|jtr<|jj|}niy|j|}WnStjtfk rd}|dk r|j d}ntj |||nX|S(sVerify that the given value is permitted as an item of this list. This may convert the value to the proper type, if it is compatible but not an instance of the item type. Returns the value that should be used as the item, or raises an exception if the value cannot be converted. @param kw: optional dictionary of standard constructor keywords used when exceptions must be built. In particular, C{_location} may be useful. R)N( R0R+RAR_R:RR{RR/RQR,(RRRLRX((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_ValidatedItem2s  csdtkrd}t|tjrR|jfdd}nt|tjrg|D]}|j||^qk}|fdqntt t |dfd}||S(NiiRcsS(N((RRL(RD(sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRYs( R>R0RRCtsplitR)R*R?RRR((RRDRLtarg1t_vtnew_arg1R((RDsG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRMs  %$cCs t|S(N(R>(RR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR \scCs,djg|D]}|jj|^q S(sCConvert from a binding value to a string usable in an XML document.R(R5R+R(RRRB((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR`scCsA|j}|r|S|d|jjdtg}dj|S(Ns , list of R1R(RR+R2R;R5(RR1R6RR7((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR2es  cCs |j|S(N(R?(RR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt __ConvertOnenscCs g|D]}|j|^qS(N(R?(R tvaluesRB((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt __convertManysscCsZt|tr4tt|j||j|n"tt|j||j|dS(N(R0tsliceRR(t __setitem__t_STD_list__convertManyR?(R tkeyR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRHvs%cCs)tt|j|||j|dS(N(RR(t __setslice__RI(R tstarttendRE((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRK}scCstt|j|j|S(N(RR(t __contains__R?(R R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRNscCs#tt|j|j|dS(N(RR(RR?(R tx((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRscCs#tt|j|j|dS(N(RR(R4RI(R ROR!((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR4scCstt|j|j|S(N(RR(tcountR?(R RO((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRPscGs"tt|j|j||S(N(RR(tindexR?(R RORD((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRQscCs&tt|j||j|dS(N(RR(tinsertR?(R tiRO((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRRscCs#tt|j|j|dS(N(RR(tremoveR?(R RO((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRTsN(RRRR/R+t_STD_list__FacetMapRR?RR RRHR;R2t_STD_list__ConvertOneRIRHRReRKRNRR4RPRQRRRT(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR($s,          R1c BsXeZdZdZdZdZdZdZdZ dZ dZ dZ e ZdZe ZdZdZdZdZd Ze Zd Zd ZdZd Zd ZdZdZde e de ddddZdZdZ e!dZ"e!dZ#dZ$ddZ%dZ&dZ'e e(dZ)RS(s Class that represents a schema element within a binding. This gets a little confusing. Within a schema, the L{pyxb.xmlschema.structures.ElementDeclaration} type represents an U{element declaration}. Those declarations may be global (have a name that is visible in the namespace), or local (have a name that is visible only within a complex type definition). Further, local (but not global) declarations may have a reference to a global declaration (which might be in a different namespace). Within a PyXB binding, the element declarations from the original complex type definition that have the same U{QName} (after deconflicting the U{LocalPart}) are associated with an attribute in the class for the complex type. Each of these attributes is defined via a L{pyxb.binding.content.ElementDeclaration} which provides the mechanism by which the binding holds values associated with that element. Furthermore, in the FAC-based content model each schema element declaration is associated with an L{ElementUse} instance to locate the point in the schema where content came from. Instances that refer to the same schema element declaration share the same underlying L{pyxb.binding.content.ElementDeclaration}. This element isn't any of those elements. This element is the type used for an attribute which associates the name of a element with data required to represent it, all within a particular scope (a module for global scope, the binding class for a complex type definition for local scope). From the perspective of a PyXB user they look almost like a class, in that you can call them to create instances of the underlying complex type. Global and local elements are represented by instances of this class. cCs|jS(s2The expanded name of the element within its scope.(t_element__name(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRscCs |jjS(s>The L{_TypeBinding_mixin} subclass for values of this element.(t_element__typeDefinitionRT(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRscCs|jS(sKThe L{pyxb.utils.utility.Location} where the element appears in the schema.(t_element__xsdLocation(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt xsdLocationscCs|jS(sThe scope of the element. This is either C{None}, representing a top-level element, or an instance of C{complexTypeDefinition} for local elements.(t_element__scope(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pytscopescCs|jS(svIndicate whether values matching this element can have U{nil } set.(t_element__nillable(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRJscCs|jS(sdIndicate whether this element is abstract (must use substitution group members for matches).(t_element__abstract(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pytabstractscCs|jS(s;Contents of any documentation annotation in the definition.(t_element__documentation(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt documentationscCs|jS(sThe default value of the element. C{None} if the element has no default value. @note: A non-C{None} value is always an instance of a simple type, even if the element has complex content.(t_element__defaultValue(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt defaultValuescCs|jS(s0C{True} if the element content cannot be changed(t_element__fixed(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pytfixedscCs|jS(sThe L{element} instance to whose substitution group this element belongs. C{None} if this element is not part of a substitution group.(t_element__substitutionGroup(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pytsubstitutionGroupscCs(||_|dk r$|j|_n|S(N(RfR/t_real_substitutesForR[(R tsubstitution_group((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_setSubstitutionGroups  cCsQ|jj|j}|dk r(|S|jdkr>dS|jj|S(N(t _ElementMapRQRR/RgtfindSubstituendDecl(R t ctd_classted((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRls  cCs|jdkrtS|dkr&tSt|ts;t|jdk r|jj}|dkrotS|jdkstn|jj|krt S|j|kp|jj |S(s>Determine whether an instance of this element can substitute for the other element. See U{Substitution Group OK}. @todo: Do something about blocking constraints. This ignores them, as does everything leading to this point. N( RgR/RHR0R1R2R\RtelementBindingR;R[(R tother((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRh s  cCstS(sPStub replaced by _real_substitutesFor when element supports substitution groups.(RH(R Rp((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR["scCs|jj|jS(sReturn a reference to the element instance used for the given name within this element. The type for this element must be a complex type definition.(Rt _UseForTagRo(R R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt memberElement&sc Cst|tjjst||_||_||_||_||_ |dk r|jj |dt |_ t|j tr|j j|_ qn||_||_| |_| |_tt|jdS(s&Create a new element binding. R!N(R0RRRR2RWRXR[R]R^R/RR;RbRzRRdRfR`RYRR1RI( R Rttype_definitionR\RJR_tunicode_defaultReRiRaRX((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRI-s          cOsT|jdd}|dks*tdd|krHtjdn||d<|jr|jd}|dkrt|tj r|j }ntj |||n|j dk r+dt |kr|j g}q+|jr+dt |kr t|n|j|d|g}q+n|jj||}|j||S( sYInvoke the Factory method on the type associated with this element. @keyword _dom_node: This keyword is removed. If present, it must be C{None}. @note: Other keywords are passed to L{_TypeBinding_mixin.Factory}. @raise pyxb.AbstractElementError: This element is abstract and no DOM node was provided. RsGCannot pass DOM node directly to element constructor; use createFromDOMR&s6Cannot set _element in element-based instance creationR)iiN(RGR/R2RRbR_RQR0RRRR)tAbstractElementErrorRbR>RdRtcompatibleValueRRR5(R RDRLRWRXRZ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt__call__Bs(      cKsF|dkr|jS|jdt}|rxt|tjsXtj|j |ng|D]}|j |^q_S|j j ||}|j r||jkrtj ||nt|tr|jdk r|jj|r|S|jrBd}t|tjr*|j}ntj|||n|S(sReturn a variant of the value that is compatible with this element. This mostly defers to L{_TypeBinding_mixin._CompatibleValue}. @raise pyxb.SimpleTypeValueError: if the value is not both type-consistent and value-consistent with the element's type. t is_pluralN(R/RbRGRHR0R)R*RtSimplePluralValueErrorRRvRnRdtElementChangeErrorRR&R[R_RRRR)Ru(R RRLRxRBt compValueRX((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRvds$  6 c Kstjjj|jkr'tdn|jd}d|krTtjdnd}|dk r|j r|jd}|dkrt |t j r|j}ntj|||n||d<|j}ntjjj|}tjtjj||||\}}|dkr<tj|ntjj|} | dk rvtjjj| |d} attribute found in C{node}, modulated by L{XSI._InterpretTypeAttribute}. @keyword _fallback_namespace: The namespace to use as the namespace for the node, if the node name is unqualified. This should be an absent namespace. @return: A binding for the DOM node. @raises pyxb.UnrecognizedDOMRootNodeError: if no underlying element or type for the node can be identified. snode is not an elementR R&s6Cannot set _element in element-based instance creationRXR%RN($txmlRtNodet ELEMENT_NODEtnodeTypeRRQRRbR/R_R0RRRR)RuRRtNamespaceContexttGetNodeContextRt_InterpretTypeAttributeRBt getAttributetUnrecognizedDOMRootNodeErrorR<RkRlRmt PushContextRt PopContextR&R2R-R( RRRRLtfallback_namespacet type_classRXtns_ctxt did_replaceRMRZ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pytCreateDOMBindings8    *  cCsXtjjj|jkr$|j}ntjj|d|}|j ||j d|S(sfCreate an instance of an element from a DOM node. This method does minimal processing of C{node} and delegates to L{CreateDOMBinding}. @param node: An C{xml.dom.Node} representing a root element. If the node is a document, that document's root node will be substituted. The name of the node is extracted as the name of the element to be created, and the node and the name are passed to L{CreateDOMBinding}. @param fallback_namespace: The value to pass as C{_fallback_namespace} to L{CreateDOMBinding} @return: As with L{CreateDOMBinding}RR ( R|RR}t DOCUMENT_NODERRRRRRRo(RRRt expanded_name((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pytAnyCreateFromDOMs cCs|j|kr|S|jj}|dkr8dS|jj|}d|jjks~td|jf|j}|dks||krdS|j|r|SdS(sQReturn the element that should be used if this element binding is permitted and an element with the given name is encountered. Normally, the incoming name matches the name of this binding, and C{self} is returned. If the incoming name is different, it is expected to be the name of a global element which is within this element's substitution group. In that case, the binding corresponding to the named element is return. @return: An instance of L{element}, or C{None} if no element with the given name can be found. RosNo element bindings in %sN(RRoR/t adoptNameRt _categoryMapR2R[(R Rttop_elttelt_ent named_elt((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pytelementForNames 1 cKsntjjj|jkr$|j}n|dk rC|jd|ntj j |d|}|j |||S(sCreate an instance of this element using a DOM node as the source of its content. This method does minimal processing of C{node} and delegates to L{_createFromDOM}. @param node: An C{xml.dom.Node} representing a root element. If the node is a document, that document's root node will be substituted. The name of the node is extracted as the name of the element to be created, and the node and the name are passed to L{_createFromDOM} @keyword fallback_namespace: Used as default for C{_fallback_namespace} in call to L{_createFromDOM} @note: Keyword parameters are passed to L{CreateDOMBinding}. @return: As with L{_createFromDOM} R RN( R|RR}RRRR/RSRRRt_createFromDOM(R RRRLR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt createFromDOMs   cKs@tjjj|jkr$|j}ntj||j||S(sTCreate an instance from a DOM node given the name of an element. This method does minimal processing of C{node} and C{expanded_name} and delegates to L{CreateDOMBinding}. @param node: An C{xml.dom.Node} representing a root element. If the node is a document, that document's root node will be substituted. The value is passed to L{CreateDOMBinding}. @param expanded_name: The expanded name of the element to be used for content. This is passed to L{elementForName} to obtain the binding that is passed to L{CreateDOMBinding}, superseding any identification that might be inferred from C{node}. If no name is available, use L{createFromDOM}. @note: Keyword parameters are passed to L{CreateDOMBinding}. @return: As with L{CreateDOMBinding}. ( R|RR}RRRR1RR(R RRRL((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs cCsd|jfS(Ns Element %s(R(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt__str__4scCstj|j}|r|S|d|jjdtdg}|jdk r}|jd|jjdtgn|j r|j dn|j dk r|jd|j jdtgn|r|j dk r|jd|j gntj dj|S( Ns (R1t)s , local to s , nillables, substitutes for s R(RRgRRR2R;R\R/R4RJRRgRatuR5(R R1R6RR7((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR27s$( (N(*RRRRR/RWRRXRZRYR\R[RJRHR]R_R^RaR`RcRbReRdRgRjRfRlRhR[RrRIRwRvRRRRRRRR;R2(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR1sH&               ! " J #   tenumeration_mixincBseZdZeddddgZedZedZedZedZ ed Z ed Z RS( sNMarker in case we need to know that a PST has an enumeration constraint facet.RRERtitemscCstj|jS(s@Return a generator for the values that the enumeration can take.(RRt_CF_enumeration(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRKscCst|jS(s6Return a list of values that the enumeration can take.(RR(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyREPscCstj|jS(sLGenerate the associated L{pyxb.binding.facet._EnumerationElement} instances.(RRR(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRUscCst|jS(sJReturn the associated L{pyxb.binding.facet._EnumerationElement} instances.(RR(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRZscCs|jj|S(sReturn the L{_EnumerationElement} instance that has the given value. @raise KeyError: the value is not valid for the enumeration.(RtelementForValue(RR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_elementForValue_scCs|jj|S(sReturn the enumeration value corresponding to the given unicode string. If ustr is not a valid option for this enumeration, return None.(RtvalueForUnicode(Rtustr((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_valueForUnicodefs( RRRRRRRRERRRR(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRFst_ContentcBsAeZdZdZdZeeZedZ dZ RS(sFBase for any wrapper added to L{complexTypeDefinition.orderedContent}.cCs|jS(sThe value of the content. This is a unicode string for L{NonElementContent}, and (ideally) an instance of L{_TypeBinding_mixin} for L{ElementContent}.(t_Content__value(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt __getValuepscs)dtjffdY}||S(s3Return an iterator that filters and maps a sequence of L{_Content} instances. The returned iterator will filter out sequence members that are not instances of the class from which the iterator was created. Further, only the L{value} field of the sequence member is returned. Thus the catenated text of the non-element content of an instance can be obtained with:: text = six.u('').join(NonElementContent.ContentIterator(instance.orderedContent())) See also L{pyxb.NonElementContent} t _Iteratorcs)eZdZdZfdZRS(cSst||_dS(N(titert_Iterator__input(R tinput((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRIscSs|S(N((R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt__iter__scs6x/tr1t|j}t|r|jSqWdS(N(R;tnextRR0R(R tcontent(R(sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt__next__s (RRRIRR((R(sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs  (RtIterator(RRR((RsG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pytContentIteratorys cCs ||_dS(N(R(R R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRIsN( RRRt_Content__getValueR/RRRRRRI(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRms   tElementContentcBs;eZdZdZdZeeZddddZRS(sqMarking wrapper for element content. The value should be translated into XML and made a child of its parent.cCs|jS(sThe L{pyxb.binding.content.ElementDeclaration} associated with the element content. This may be C{None} if the value is a wildcard.(t#_ElementContent__elementDeclaration(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt__getElementDeclarationscCsddl}tt|j||dk rat|tsO|jdn|j|}n|dkst||j j j st ||_ dS(sCreate a wrapper associating a value with its element declaration. Normally the element declaration is determined by consulting the content model when creating a binding instance. When manipulating the preferred content list, this may be inconvenient to obtain; in that case provide the C{instance} in which the content appears immediately, along with the C{tag} that is used for the Python attribute that holds the element. @param value: the value of the element. Should be an instance of L{_TypeBinding_mixin}, but for simple types might be a Python native type. @keyword element_declaration: The L{pyxb.binding.content.ElementDeclaration} associated with the element value. Should be C{None} if the element matches wildcard content. @keyword instance: Alternative path to providing C{element_declaration} @keyword tag: Alternative path to providing C{element_declaration} iNs'Unable to determine element declaration(R.RRRIR/R0Rzt UsageErrorRqRkRtElementDeclarationR2R(R Rtelement_declarationtinstancettagR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRIs  *N( RRRt&_ElementContent__getElementDeclarationR/RRtelementDeclarationRI(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs   tNonElementContentcBseZdZdZRS(s{Marking wrapper for non-element content. The value will be unicode text, and should be appended as character data.cCs#tt|jtj|dS(N(RRRIRRg(R R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRIs(RRRRI(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRsRzc Bs eZdZdZdZdZdZd0Zd0Z e Z iZ d0Z dZd0ZdZdZejjedd d d d d dddg Zd0ZedZeedZdZdZdZdZdZdZ d0dZ!d0Z"dZ#edZ$eZ%dZ&dZ'dZ(e dZ)d0Z*d Z+d!Z,d"Z-ed#Z.d$Z/d%Z0d0e d0d&Z1d'Z2d(Z3ed)Z4d*Z5d+Z6d,Z7d-Z8ed.Z9ee ed/Z:RS(1sBBase for any Python class that serves as the binding for an XMLSchema complexType. Subclasses should define a class-level _AttributeMap variable which maps from the unicode tag of an attribute to the AttributeUse instance that defines it. Similarly, subclasses should define an _ElementMap variable. tEMPTYtSIMPLEtMIXEDt ELEMENT_ONLYcCs|jS(sObtain access to wildcard attributes. The return value is C{None} if this type does not support wildcard attributes. If wildcard attributes are allowed, the return value is a map from QNames to the unicode string value of the corresponding attribute. @todo: The map keys should be namespace extended names rather than QNames, as the in-scope namespace may not be readily available to the user. (t,_complexTypeDefinition__wildcardAttributeMap(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pytwildcardAttributeMaps cCs|jS(s_Obtain access to wildcard elements. The return value is C{None} if the content model for this type does not support wildcard elements. If wildcard elements are allowed, the return value is a list of values corresponding to conformant unrecognized elements, in the order in which they were encountered. If the containing binding was created from an XML document and enough information was present to determine the binding of the member element, the value is a binding instance. Otherwise, the value is the original DOM Element node. (t(_complexTypeDefinition__wildcardElements(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pytwildcardElementss cOss|jdd }t}|jdd }|jdd }|jd|d k }|jdd }|d k r |d krt|tjjjr|j}nt j j j |j kr|j}ntjj|}|d k r tjjj|}|d} (not L{name }) matches the keyword. @keyword _dom_node: The node to use as the source of binding content. @type _dom_node: C{xml.dom.Element} @keyword _location: An optional instance of L{pyxb.utils.utility.Location} showing the origin the binding. If C{None}, a value from C{_dom_node} is used if available. @keyword _from_xml: See L{_TypeBinding_mixin.Factory} @keyword _finalize_content_model: If C{True} the constructor invokes L{_TypeBinding_mixin._finalizeContentModel} prior to return. The value defaults to C{False} when content is assigned through keyword parameters (bypassing the content model) or neither a C{_dom_node} nor positional element parameters have been provided, and to C{True} in all other cases. R RR)R!t_finalize_content_modelR%t_strict_keywordsisACannot mix keyword and positional args for element initializationR$R'N(6RGR/RHR0RR!RRRR)R|RR}RRRRR<RRkRlRmRVRRt_HasWildcardElementRR^tAbstractInstantiationErrorRBRRzRItresetRRRRkRR;RRtUnprocessedKeywordContentErrorR>RR4t _CT_SIMPLEt_ContentTypeTagt_TypeDefinitionRR7RFRt childNodesR(R RDRLRRMRWRXRtdo_finalize_content_modeltdid_set_kw_eltRRt_fkwR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRI sd $  #         &=  RRRRtorderedContentRR4RRcCs|j|jj|S(sSMethod used by generated code to associate the element binding with a use in this type. This is necessary because all complex type classes appear in the module prior to any of the element instances (which reference type classes), so the association must be formed after the element instances are available.(RqRt_setElementBinding(RR1((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt _AddElementcscCs;y|j|}Wn#tk r6|r-nd}nX|S(sReturn the ElementDeclaration object corresponding to the element name. @param tag: The L{ExpandedName} of an element in the class.N(RktKeyErrorR/(RRt raise_if_failRZ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRqms  cCsg}xtj|jD]}|j|}|dkr@qnt|tr|jr|jg|D]}t ||^qhqn|j t ||qW|S(s9Generate a list of children in the order in which they should be added to the parent when creating a DOM representation of this object. @note: This is only used when L{pyxb.RequireValidWhenGenerating} has disabled validation. Consequently, it may not generate valid XML. N( RRRkRR/R0RtisPluralR4RR(R torderRnRRB((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt__childrenForDOMzs )cCs6|j|j|jfkrgS|j|jjS(seProvide the child elements and non-element content in an order consistent with the content model. Returns a sequence of tuples representing a valid path through the content model where each transition corresponds to one of the member element instances within this instance. The tuple is a pair comprising the L{content.ElementDeclaration} instance and the value for the transition. If the content of the instance does not validate against the content model, an exception is raised. @return: C{None} or a list as described above. (Rt _CT_EMPTYRt_resetAutomatont._complexTypeDefinition__automatonConfigurationtsequencedChildren(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_validatedChildrens cCsi}xtj|jD]}|j|}|dkr@qn|jj}|jrdt|krg|D]}||^qt||R(R RZteuRt converterRBtwce((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt _symbolSets  ) cCs.x'tj|jD]}|j|qWdS(N(RRRtvalidate(R tau((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_validateAttributesscCs|jrL|jr'|jdk s0|jrHtj||jntS|jr|jdkrtj||jn|j }xv|D]n}t |t rqnt |j t r|j jq|jdk rtjd|j |jjqqW|jtS(Ns$Cannot validate value %s in field %s(R7Rwt_complexTypeDefinition__contentR/RR@R;RR)RR0RRRRRRrtwarningRR(R RR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs  $  & cCsu|jj|}|dkr[|jdkrKtjt|||n||j|} and L{non-element} content in the order which it was added to the instance. This may have been through parsing a document, constructing an instance using positional arguments, invoking the L{append} or L{extend} methods, or assigning directly to an instance attribute associated with an element binding. @note: Be aware that assigning directly to an element attribute does not remove any previous value for the element from the content list. @note: Be aware that element values directly appended to an instance attribute with list type (viz., that corresponds to an element that allows more than one occurrence) will not appear in the ordered content list. The order in the list may influence the generation of documents depending on L{pyxb.ValidationConfig} values that apply to an instance. Non-element content is emitted immediately prior to the following element in this list. Any trailing non-element content is emitted after the last element in the content. The list should include all element content. Element content in this list that is not present within an element member of the binding instance may result in an error, or may be ignored. @note: The returned value is mutable, allowing the caller to change the order to be used. @raise pyxb.NotComplexContentError: this is not a complex type with mixed or element-only content (RRRRtNotComplexContentErrorR(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRs#cCsH|jrDddl}t|_tjddj|jd ndS(NisXDeprecated complexTypeDefinition method "content" invoked Please use "orderedContent" %sRi(t)_complexTypeDefinition__NeedWarnOnContentt tracebackRHRrRR5t format_stack(RR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt__WarnOnContent" s    #cCsT|j|j|j|jfkr7tj|ng|jD]}|j^qAS(sLegacy interface for ordered content. This version does not accurately distinguish non-element content from element content that happens to have unicode type. @deprecated: use L{orderedContent}.(t%_complexTypeDefinition__WarnOnContentRRRRRRR(R RB((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR+ s cCs+|j|jkr$tj|n|jS(sReturn the value of the element. This must be a complex type with simple content. The returned value is expected to be an instance of some L{simpleTypeDefinition} class. @raise pyxb.NotSimpleContentError: this is not a complex type with simple content (RRRRR(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR7 scCs|j|jkr$tj|n|j}|jrc|dk rtj|||qnPt||j s|j j |}n|j ||j j r|j|n|S(s=Change the simple content value without affecting attributes.N(RRRRR)R7R/R@R0RRt"_complexTypeDefinition__setContentRR R(R RRX((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt _setValueC s     cCsj|r3x*tj|jD]}|j|qWnd}|j|j|jfkr]g}n|j|S(N( RRRkRR/Rt _CT_MIXEDt_CT_ELEMENT_ONLYR(R R8Rtnv((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR:S s cCs\|jdk rU|jdkrEddl}|jjj||_n|jjn|jS(Ni(t _AutomatonR/RR.RkRtAutomatonConfigurationR(R R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR] s  cCs|jS(sFor whitebox testing use only(R(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_automatonConfiguratione scCsH|jdtx'tj|jD]}|j|q#W|j|S(sReset the instance. This resets all element and attribute fields, and discards any recorded content. It resets the content model automaton to its initial state. @see: Manipulate the return value of L{orderedContent} if your intent is to influence the generation of documents from the binding instance without changing its (element) content. R8(R:R;RRRRR(R R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRi s  cCs|jj|}d}|dkrly|j}Wntjk rJnX|dk rx|j|}qxn |j}||fS(s Determine what the given name means as an element in this type. Normally, C{element_name} identifies an element definition within this type. If so, the returned C{element_decl} identifies that definition, and the C{element_binding} is extracted from that use. It may also be that the C{element_name} does not appear as an element definition, but that it identifies a global element. In that case, the returned C{element_binding} identifies the global element. If, further, that element is a member of a substitution group which does have an element definition in this class, then the returned C{element_decl} identifies that definition. If a non-C{None} C{element_decl} is returned, there will be an associated C{element_binding}. However, it is possible to return a non-C{None} C{element_binding}, but C{None} as the C{element_decl}. In that case, the C{element_binding} can be used to create a binding instance, but the content model will have to treat it as a wildcard. @param element_name: The name of the element in this type, either an expanded name or a local name if the element has an absent namespace. @return: C{( element_binding, element_decl )} N(RkRQR/RoRtNamespaceErrorRl(RRt element_declR((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_ElementBindingDeclForName{ s   c Ks|jdd}|jdt}|jdd}|jrZtj|||n|jdd}|jd|jj}|jdt}d} |dk rddl m } t || j st |j} | dk st nt |tjjrt}|st | dks*t |} tjj}tjjj| jkrX|S| jtjjjtjjjfkr| j}t}qtjjj| jkst tjj| d |} |j| \} }| dk r| j| | d|}qtjj| } t}| dk r]tjj j!| }tj"| ||d\}}n|r~t#j$| dd|}qt%j&d | t'| d d n| rt |t(j)r|j*|j+|j,fkrd t-|j.kr|j r|Sn|r|j/dk r|sv|dk r;|j0|||S|j1dk r[|j2||Stj3d|d|n|j/j4||}d|kr|Sn| dk st |tjjt5tj6fst |t7r/|j8p|j9 r/|j/rtj:||j/||ntj;||n|j8r|j<dk r_tj=||n|jst ||j>s|j>j?|d|}n|j@||r|jA|qn|S|j9stjB|||n|jCtD||S(sAdd the value to the instance. The value should be a DOM node or other value that is or can be converted to a binding instance, or a string if the instance allows mixed content. The value must be permitted by the content model. @raise pyxb.ContentValidationError: the value is not permitted at the current state of the content model. t _element_declt_maybe_elementR)R t_require_validationR!i(RRs.Unable to convert DOM node %s at %s to bindingRXs [UNAVAILABLE]it containerRiN(ERQR/R;R7RR@RR RHt pyxb.bindingRR0RR2RoR|RR}Rt COMMENT_NODERt TEXT_NODEtCDATA_SECTION_NODEtdataR~RRRRRRBRRRRR1RRrRRRRCRRRR>tstripRt setOrAppendRt_appendWildcardElementtStructuralBadDocumentErrortstepRzRuRpRwt_IsMixedtUnrecognizedContentErrortNonElementValidationErrorRtExtraSimpleContentErrorRRRRtMixedContentErrort _addContentR(R RRLRt maybe_elementRXRtrequire_validationRRRRRtxsi_typet try_createRRtnum_cand((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR s      '    !"4%    !(     cCst|tjjs3t|tr\|jdk r\|jt|d|j j |n4|j r~|jt |nt j||dS(N(R0R|RR}RR&R/R RRRRRRR (R R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR" s cCsBi|d6|d6|d6}g|D]}|j||^q"|S(s5Invoke L{append} for each value in the list, in turn.R R!R)(R(R t value_listR R!R)RLRB((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR4/ s   #cCs||_|jS(N(R(R R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt __setContent7 s cCs|j|j|jfks!tt|ts6t|jj|t|tr|j }|j }t|t r|dk r|j dkrt|jtst|j|jqndS(N(RRRR2R0RRRRRRRR/R&RoR1R5(R t wrapped_valueRRn((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR ; s!  -cCs|j|jkS(N(RR(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRI scCs|jr|jjndS(N(RtresolveNondeterminism(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRM s cCs|j|jjr|j r{|jdk r{|jjs{|jrhtj ||j n|jj q{n|j n|S(N( RRR R7RR/t isAcceptingRwRRR)tdiagnoseIncompleteContentR(R ((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRR s    cCsxItj|jD]5}tjjr5|j|n|j|||qW|jrx6tj |jD]\}}|j |||qhWn|S(sGAdd any appropriate attributes from this instance into the DOM element.( RRRRRRRtaddDOMAttributeRRR(R RR1Rtantav((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyt_setDOMFromAttributes_ s  cs|}|j||jr%nt|j|jkr:n_|j|jkr|jdkrvtj||j nj |j |n tj j r|j}n |j}x|D]}t|j t|kstt|tr j |j |qn|jdkr_t|j tjjrIj|j |qx|j j|q|jj||j qW|j}x|D]}qWttt|dfd|S(sMCreate a DOM element with the given tag holding the content of this instance.RcsS(N((RR(R(sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR sN(RR7RRRRR/RRR)R$RRRRt&_complexTypeDefinition__childrenForDOMRR2R0RRR|RR}t appendChildRRRRRz(R RRR1RRt mixed_contenttmc((RsG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRj s6    !  cCs|j|jkS(s8CTDs with simple content are simple; other CTDs are not.(RR(R((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRw sc Cs|j}|r|S|g}|j|jkrA|jdn~|j|jkrx|jd|jjdtgnG|j |jkr|jdn%|j |jkst |jddt |j ks|jdk rS|jd|jdjgtj|j D]}|jd t^q|jdk rS|jd qSndt |jksq|jr|jd |jdjgtj|jD]}|jd t^q|jr|jd qnd j|S(Ns, empty contents, simple content type R1s, mixed contents, element-only contentis Attributes: s R6s Wildcard attribute(s)s Elements: s Wildcard element(s)R(RRRRRR4RR2R;RRR2R>RRR/R5RRRHRkR(RR1R6RR7t_aut_eu((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyR2 s.  % $ A A N(;RRRRRRRR/RRRHRRkRRRRRIRRR9RRRRR;RqRRRRRRRRRRRRRRR:RRRRRRRR4RR RRRRRRwR2(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyRzsj   P!    #    '     '     "($RtloggingR)txml.domR|Rt pyxb.utilsRRRtpyxb.namespacetpyxb.namespace.builtinRRRxt getLoggerRRrRRRtcscRootRRRt_DeconflictSymbols_mixinRpR_t list_typeR(R1RRRRRRz(((sG/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/basis.pyts4      TLms'+,