e#]c@s[dZddlZddlZddlZddlZddlZddlmZddl Zddl m Z ej e ZdejfdYZdefdYZd ejjjfd YZd efd YZd efdYZddlZejjjdejfdYZdefdYZdefdYZdS(sHelper classes that maintain the content model of XMLSchema in the binding classes. L{AttributeUse} and L{ElementDeclaration} record information associated with a binding class, for example the types of values, the original XML QName or NCName, and the Python field in which the values are stored. They also provide the low-level interface to set and get the corresponding values in a binding instance. L{Wildcard} holds content-related information used in the content model. iN(tbasis(tsixt AttributeUsecBseZdZdZdZdZdZdZdZ e Z e Z e Z de e e dZdZdZdZdZdZdZdZd Zd Zd Zd Zd ZdZdZdZdZe dZe e dZ!RS(sA helper class that encapsulates everything we need to know about the way an attribute is used within a binding class. Attributes are stored internally as pairs C{(provided, value)}, where C{provided} is a boolean indicating whether a value for the attribute was provided externally, and C{value} is an instance of the attribute datatype. The C{provided} flag is used to determine whether an XML attribute should be added to a created DOM node when generating the XML corresponding to a binding instance. c Cs||_||_||_||_||_|jdk r]|jj|jdt|_n||_ ||_ ||_ t t |jdS(s9 Create an AttributeUse instance. @param name: The name by which the attribute is referenced in the XML @type name: L{pyxb.namespace.ExpandedName} @param id: The Python identifier for the attribute within the containing L{pyxb.basis.binding.complexTypeDefinition}. This is a public identifier, derived from the local part of the attribute name and modified to be unique, and is usually used as the name of the attribute's inspector method. @type id: C{str} @param key: The string used to store the attribute value in the dictionary of the containing L{pyxb.basis.binding.complexTypeDefinition}. This is mangled so that it is unique among and is treated as a Python private member. @type key: C{str} @param data_type: The class reference to the subclass of L{pyxb.binding.basis.simpleTypeDefinition} of which the attribute values must be instances. @type data_type: C{type} @keyword unicode_default: The default value of the attribute as specified in the schema, or None if there is no default attribute value. The default value (of the keyword) is C{None}. @type unicode_default: C{unicode} @keyword fixed: If C{True}, indicates that the attribute, if present, must have the value that was given via C{unicode_default}. The default value is C{False}. @type fixed: C{bool} @keyword required: If C{True}, indicates that the attribute must appear in the DOM node used to create an instance of the corresponding L{pyxb.binding.basis.complexTypeDefinition}. The default value is C{False}. No more that one of L{required} and L{prohibited} should be assigned C{True}. @type required: C{bool} @keyword prohibited: If C{True}, indicates that the attribute must B{not} appear in the DOM node used to create an instance of the corresponding L{pyxb.binding.basis.complexTypeDefinition}. The default value is C{False}. No more that one of L{required} and L{prohibited} should be assigned C{True}. @type prohibited: C{bool} @raise pyxb.SimpleTypeValueError: the L{unicode_default} cannot be used to initialize an instance of L{data_type} t _from_xmlN(t_AttributeUse__namet_AttributeUse__idt_AttributeUse__keyt_AttributeUse__dataTypet_AttributeUse__unicodeDefaulttNonetFactorytTruet_AttributeUse__defaultValuet_AttributeUse__fixedt_AttributeUse__requiredt_AttributeUse__prohibitedtsuperRt__init__( tselftnametidtkeyt data_typetunicode_defaulttfixedtrequiredt prohibited((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyROs4     !   cCs|jS(sZThe expanded name of the element. @rtype: L{pyxb.namespace.ExpandedName} (R(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs|jS(s#The default value of the attribute.(R (R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt defaultValuescCs|jS(s9C{True} iff the value of the attribute cannot be changed.(R (R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs|jS(s3C{True} iff the attribute must be assigned a value.(R(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs|jS(s7C{True} iff the attribute must not be assigned a value.(R(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs |j|S(sC{True} iff the given instance has been explicitly given a value for the attribute. This is used for things like only generating an XML attribute assignment when a value was originally given (even if that value happens to be the default). (t_AttributeUse__getProvided(Rt ctd_instance((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytprovidedscCs|jS(szTag used within Python code for the attribute. This is not used directly in the default code generation template.(R(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs|jS(sIString used as key within object dictionary when storing attribute value.(R(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs|jS(slThe subclass of L{pyxb.binding.basis.simpleTypeDefinition} of which any attribute value must be an instance.(R(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytdataTypescCst||jtdfS(sRetrieve the value information for this attribute in a binding instance. @param ctd_instance: The instance object from which the attribute is to be retrieved. @type ctd_instance: subclass of L{pyxb.binding.basis.complexTypeDefinition} @return: C{(provided, value)} where C{provided} is a C{bool} and C{value} is C{None} or an instance of the attribute's datatype. N(tgetattrRtFalseR (RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt __getValues cCs|j|dS(Ni(t_AttributeUse__getValue(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt __getProvidedscCs;|jr*tjt||j|n|j|dS(s1Get the value of the attribute from the instance.i(RtpyxbtProhibitedAttributeErrorttypeRR#(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytvalues !cCst||j||fS(N(tsetattrR(RRt new_valueR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt __setValuescCs|j||jtdS(s}Set the value of the attribute in the given instance to be its default value, and mark that it has not been provided.N(t_AttributeUse__setValueR R!(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytresetscCs8|j|\}}|r4|j||j|n|S(sRIf this attribute as been set, add the corresponding attribute to the DOM element.(R#t addAttributeR(Rt dom_supportRtelementRR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytaddDOMAttributescCs|j|\}}|dk r|jrKtjt||j|n|jr| r|jsjt tj t||j|n|j j ||j j |n*|jrtj t||j|ndS(szValidate the instance against the requirements imposed by this attribute use. There is no return value; calls raise an exception if the content does not validate. @param ctd_instance : An instance of a complex type definition. @raise pyxb.ProhibitedAttributeError: when instance has attribute but must not @raise pyxb.MissingAttributeError: when instance lacks attribute but must have it (including when a required fixed-value attribute is missing). @raise pyxb.BatchContentValidationError: when instance has attribute but its value is not acceptable N(R#R RR%R&R'RRR tAssertionErrortMissingAttributeErrorRt_CheckValidValuetXsdConstraintsOK(RRRR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytvalidates  !! cCst}t|tjj s"t|dkra|jrXtj t ||j |nt }n|j rtjt ||j |n|dk r|st||j r|jj|d|}n|jr||jkrtjt ||j |n|j||||S(sSet the value of the attribute. This validates the value against the data type, creating a new instance if necessary. @param ctd_instance: The binding instance for which the attribute value is to be set @type ctd_instance: subclass of L{pyxb.binding.basis.complexTypeDefinition} @param new_value: The value for the attribute @type new_value: Any value that is permitted as the input parameter to the C{Factory} method of the attribute's datatype. @param from_xml: Value C{True} iff the new_value is known to be in lexical space and must by converted by the type factory. If C{False} (default) the value is only converted if it is not already an instance of the attribute's underlying type. RN(R t isinstancetxmltdomtNodeR2R RR%R3R'RR!RR&RR R R tAttributeChangeErrorR,(RRR*tfrom_xmlR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytsets  !  !%!c Cs|rtj|jSt|jtjs1ttj|jdtj|jd|jj dt dt dg}|j r|j dn&|jr|j dn |j d|jdk r|j d |jr|j d n |j d |jd |jgnd j|S(Ns: s (t name_onlytuser_documentations), RRtoptionals, Rtdefaultt=t(Rt text_typeRt issubclassRRt_TypeBinding_mixinR2Rt _descriptionR R!RtappendRR R R textendRtjoin(RR>R?tdesc((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRGs E      N("t__name__t __module__t__doc__R RRRRRR R!R RRRRRRRRRRRRR#RR(R,R-R1R6R=R RG(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR(s: @               tAutomatonConfigurationcBseZdZdZdZdZdZdZdZ dZ dZ e dZ dZedZd Zd Zd ZdZdZd Zdd ZdZdZRS(s$State for a L{pyxb.utils.fac.Automaton} monitoring content for an incrementally constructed complex type binding instance. @warning: This is not an implementation of L{pyxb.utils.fac.Configuration_ABC} because we need the L{step} function to return a different type of value.icCs ||_dS(N(t!_AutomatonConfiguration__instance(Rtinstance((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyROscCs"|jjj|_d|_dS(sReset the automaton to its initial state. Subsequent transitions are expected based on candidate content to be supplied through the L{step} method.N(RPt _AutomatontnewConfigurationt_AutomatonConfiguration__cfgR t_AutomatonConfiguration__multi(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR-RscCs5|jdk r(|jdks$tdSt|jS(sReturn the number of pending configurations. The automaton is deterministic if exactly one configuration is available.iN(RTR RUR2tlen(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytnondeterminismCountZscCs`||f}g}|jdkr6|jdfg}n |j}x~|D]v\}}|j|}xX|D]P} i} |j| } |j| j| | || jj|ffqiWqGWt |} d| krdSd| kr&d|_|d\|_} xT| D]}||j q Wn6| |j krJt j |j nd|_||_| S(sAttempt a transition from the current state. @param value: the content to be supplied. For success the value must be consistent with the recorded symbol (element or wildcard declaration) for a transition from the current automaton state. @param element_decl: optional L{pyxb.binding.content.ElementDeclaration} that is the preferred symbol for the transition. @return: the cardinal number of successful transitions from the current configuration based on the parameters.iiN((RUR RTtcandidateTransitionstcloneRHtapplytconsumedSymboltconsumingClosureRVRPtPermittedNondeterminismR%t"ContentNondeterminismExceededError(RR(t element_decltsymt new_multitmultitcfgtpendingtcandt transitiont clone_maptccfgtrvtactionstfn((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytstepds0   =       cCs|jdkrdS|jdks(t|j}|rsttd|j}dt|krs|j}qsndt|kstdt|kr|jj}|dkrt |j}nt j d|n|d\|_}d|_x|D]}||jqWdS(sResolve any non-determinism in the automaton state. If the automaton has reached a single configuration (was deterministic), this does nothing. If multiple candidate configurations are available, the best one is selected and applied, updating the binding instance with the pending content. "Best" in this case is determined by optionally eliminating configurations that are not accepting, then selecting the path where the initial transition sorts highest using the binding sort key (based on position in the original schema). @keyword prefer_accepting: eliminate non-accepting paths if any accepting path is present.NcSs|djS(Ni(t isAccepting(t_ts((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytsiisMultiple accepting paths for %s( RUR RTR2tlisttfilterRVRPt _ExpandedNameR't_logtwarning(Rtprefer_acceptingRbRKRjRk((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytresolveNondeterminisms&     cCsg}t}|j}|dkr3|jg}nxN|D]F}x=|jD]/}||krM|j||j|qMqMWq:W|S(sReturn the sequence of acceptable symbols at this state. The list comprises the L{pyxb.binding.content.ElementUse} and L{pyxb.binding.content.WildcardUse} instances that are used to validate proposed symbols, in preferred order.N(R=RUR RTtacceptableSymbolsRHtadd(RRitseenRbRctu((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytacceptableContents      cCs?|jt|j}x|jdk r4|j}qW|jS(sReturn C{True} iff the automaton is in an accepting state. If the automaton has unresolved nondeterminism, it is resolved first, preferring accepting states.N(RvR RTtsuperConfigurationR Rm(Rtraise_if_rejectingRc((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRms    cCsb|j}x(|jr3|jdk r3|j}q W|js^tj|j|||n|S(sCheck for incomplete content. @raises pyxb.IncompleteElementContentError: if a non-accepting state is found @return: the topmost configuration (if accepting) N(RTRmR|R R%tIncompleteElementContentErrorRP(Rtsymbolst symbol_setRc((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt_diagnoseIncompleteContents    cCs|jddS(s@Generate the exception explaining why the content is incomplete.N(RR (R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytdiagnoseIncompleteContentsicCsd|_d|_d|_|j}d}|j|jks`|j|jkr|j |jkr|j }|j|jkrg|_qn|S(Ni( t/_AutomatonConfiguration__preferredSequenceIndexR t/_AutomatonConfiguration__preferredPendingSymbolt1_AutomatonConfiguration__pendingNonElementContentt_validationConfigtALWAYStcontentInfluencesGenerationt_ContentTypeTagt _CT_MIXEDt MIXED_ONLYtorderedContent(RRQtvctpreferred_sequence((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt__resetPreferredSequences    6 cCsq|dkr|j}n|j}|dk rmx=||D].}t|tjjjr8|j|q8q8WndS(sAExtract non-element content from the sequence and return C{None}.N( R RRR7R%tbindingRtNonElementContentRH(RRtpitnectcsym((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt__discardPreferredSequences    c Cs|j}|j}|j}|dk rCtjd|d|_nx1|dkrv|t|krz|j||}Pn||}|d7}|dk rt|t j j j r|j |qFn|j|jg}|j|kr|j|jf}Pn|dkrFtjd||j|jkr3qFn|j|jkr[|j||}Pnt j|j|qFqFW||_||fS(Ns restoring %sisorphan %s in content(RRRR RstinfoRVt1_AutomatonConfiguration__discardPreferredSequenceR7R%RRRRHtgettelementDeclarationR(t IGNORE_ONCEtorphanElementInContenttGIVE_UPtOrphanElementContentErrorRP( RRRRRtpsymRRtvals((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt__processPreferredSequences:       $   cCs3|j|j}g}|j}|j}|j}|j|}|j}d}x|rid} d}|dk r|j|||\}}n|j |} x%| D]} | j } t | t r| j } n$t | trd} n tst|j| }|dkrqn| j|d| fs>qn|jd}|dk r||dk r||j|g|(n|jtj| j|| f| | } dt|kr|| =nPqW| dkrW|dk rStjd||j|jkr qXn|j|jkr2|j|}qXnt j!|j||||nPn| j"|}qXW|j#||}|rt j$|j|||nxp|dk r|j|||\}}|dk r|j%|j|jfkrt j&|j|j'qqqW|dk r/|j|n|S(swImplement L{pyxb.binding.basis.complexTypeDefinition._validatedChildren}. Go there for the interface. isinvalid %s in contentN((R-RTRPRt _symbolSett/_AutomatonConfiguration__resetPreferredSequenceRR t1_AutomatonConfiguration__processPreferredSequenceRXR[R7t ElementUseRt WildcardUseR!R2RtmatchtpopRIRHRtElementContentt matchValueRVRsRRtinvalidElementInContentRRR%t#InvalidPreferredElementContentErrorRZRtUnprocessedElementContentErrorRRR((RRcRRQRRRRRt selected_xitt candidatestxitRtedtmatchesR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytsequencedChildren/st               (   ! " N(RLRMRNR RPRTRUR]RR-RWRlR RvR{R!RmRRRRRRRRR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRO0s*   2 .    t _FACSymbolcBs8eZdZdZdZdZdZdZRS(sBase class for L{pyxb.utils.fac.Symbol} instances associated with PyXB content models. This holds the location in the schema of the L{ElementUse} or L{WildcardUse} and documents the methods expected of its children.cCs|jS(N(t_FACSymbol__xsdLocation(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt xsdLocationscCs tdt|jfdS(sReturn the value accepted by L{match} for this symbol. A match for an element declaration might have resulted in a type change for the value (converting it to an acceptable type). There is no safe place to cache the compatible value calculated in the match while other candidates are being considered, so we need to re-calculate it if the transition is taken. If the match could not have changed the value, the value from the symbol may be returned immediately.s%s._matchValueN(tNotImplementedErrorR'RL(RR`((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs cCs tdt|jfdS(sCreate a closure that will apply the value from C{sym} to a to-be-supplied instance. This is necessary for non-deterministic automata, where we can't store the value into the instance field until we know that the transition will be taken: @return: A closure that takes a L{complexTypeDefinition} instance and stores the value from invoking L{matchValue} on C{sym} into the appropriate slot.s%s._consumingClosureN(RR'RL(RR`((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR\s cCs ||_tt|jdS(sm@param xsd_location: the L{location} of the element use or wildcard declaration.N(RRRR(Rt xsd_location((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs N( RLRMRNR RRRR\R(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs   RcBs\eZdZd ZdZdZdZdZdZ dZ dZ dZ RS( stInformation about a schema element declaration reference. This is used by the FAC content model to identify the location within a schema at which an element use appears. The L{ElementDeclaration} is not sufficient since multiple uses in various schema, possibly in different namespaces, may refer to the same declaration but be independent uses. cCs|jS(scReturn the L{element declaration} associated with the use.(t_ElementUse__elementDeclaration(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs |jjS(sReturn the L{element binding} associated with the use. Equivalent to L{elementDeclaration}().L{elementBinding()}.(RtelementBinding(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs|jjjS(sReturn the element type. Equivalent to L{elementDeclaration}().L{elementBinding()}.L{typeDefinition()}.(RRttypeDefinition(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs#tt|j|||_dS(N(RRRR(Rtelement_declarationR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs7|\}}|jj||\}}|s3t|S(N(Rt_matchesR2(RR`R(R_Ri((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs  cCs ||dS(NcSs|jj||j|S(N(Rt setOrAppendR(t_instt_eut_sy((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRos((RR`((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR\scCs+|\}}|jj||\}}|S(sSatisfy L{pyxb.utils.fac.SymbolMatch_mixin}. Determine whether the proposed content encapsulated in C{symbol} is compatible with the element declaration. If so, the accepted value is cached internally and return C{True}; otherwise return C{False}. @param symbol: a pair C{(value, element_decl)}. L{pyxb.binding.content.ElementDeclaration._matches} is used to determine whether the proposed content is compatible with this element declaration.(RR(RtsymbolR(R_Ri((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs cCsd|jj|jfS(Ns %s per %s(RRR(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt__str__sN( RLRMRNR RRRRRRR\RR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs       RcBsJeZdZdZdZdZdZdZdZ dZ RS(sInformation about a schema wildcard element. This is functionally parallel to L{ElementUse}, but references a L{Wildcard} that is unique to this instance. That L{Wildcard} is not incorporated into this class is an artifact of the evolution of PyXB.cCs|jS(N(t!_WildcardUse__wildcardDeclaration(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytwildcardDeclarationscCs|\}}|S(N((RR`R(R_((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs cCs|j|dS(s]Create a closure that will apply the value accepted by L{match} to a to-be-supplied instance.cSs |j|S(N(t_appendWildcardElement(Rt_av((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRos(R(RR`((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR\scCs|\}}|jjd|S(sSatisfy L{pyxb.utils.fac.SymbolMatch_mixin}. Determine whether the proposed content encapsulated in C{symbol} is compatible with the wildcard declaration. If so, the accepted value is cached internally and return C{True}; otherwise return C{False}. @param symbol: a pair C{(value, element_decl)}. L{pyxb.binding.content.Wildcard.matches} is used to determine whether the proposed content is compatible with this wildcard. N(RRR (RRR(R_((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR s cCs#tt|j|||_dS(N(RRRR(Rtwildcard_declarationR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCsd|jfS(Ns xs:any per %s(R(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRsN( RLRMRNR RRRR\RRR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs     t_PluralBindingcBseZdZdZdZdZdZdZdZ dZ dZ dZ dZ d Zd Zd Zd Zd ddZdZddZdZdZdedZdZdZdZdZRS(sHelper for element content that supports multiple occurences. This is an adapter for Python list. Any operation that can mutate an item in the list ensures the stored value is compatible with the element for which the list holds values.cOsS|jdd}t|tjs0tn||_g|_|j|dS(Ntelement_binding( RR R7RR0t ValueErrort_PluralBinding__elementBindingt_PluralBinding__listRI(RtargstkwR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR1s    cCs|jj|S(N(RtcompatibleValue(Rtv((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt __convert9scCs |jjS(N(Rt__len__(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR<scCs|jj|S(N(Rt __getitem__(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR?scCsat|trA|jj|g|D]}|j|^q"n|jj||j|dS(N(R7tsliceRt __setitem__t_PluralBinding__convert(RRR(t_v((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRBs2cCs|jj|dS(N(Rt __delitem__(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRHscCs |jjS(N(Rt__iter__(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRKscCs |jjS(N(Rt __reversed__(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRNscCs|jj|S(N(Rt __contains__(Rtitem((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRQscCs|jj|j|dS(N(RRHR(Rtx((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRHUscCs |jjt|j|dS(N(RRItmapR(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRIXscCs|jj|S(N(Rtcount(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR[siicCs|jj|||S(N(Rtindex(RRtitj((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR^scCs |jj||j|dS(N(RtinsertR(RRR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRascCs|jj|S(N(RR(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRdscCs|jj|dS(N(Rtremove(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRgscCs|jjdS(N(Rtreverse(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRjscCs|jjd|d|dS(NRR(Rtsort(RRR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRmscCs |jjS(N(RR(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRpscCs t|jS(N(thasht__list__(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt__hash__sscCsB|dkrtSt|tr2|jj|jS|jj|S(N(R R!R7RRt__eq__(Rtother((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRvs  cCsB|dkrtSt|tr2|jj|jS|jj|S(N(R R!R7RRt__lt__(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR}s  N(RLRMRNR RRRRRRRRRRRRHRIRRRRRRR!RRRRR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR&s2                   tElementDeclarationcBseZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZeZddZdZd Zd Zd Zd Zd ZdZdZeedZdZdZRS(s?Aggregate the information relevant to an element of a complex type. This includes the L{original tag name}, the spelling of L{the corresponding object in Python }, an L{indicator} of whether multiple instances might be associated with the field, and other relevant information. cCs|jS(sThe L{location} in the schema where the element was declared. Note that this is not necessarily the same location as its use.(t _ElementDeclaration__xsdLocation(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs|jS(sZThe expanded name of the element. @rtype: L{pyxb.namespace.ExpandedName} (t_ElementDeclaration__name(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs|jS(sThe string name of the binding class field used to hold the element values. This is the user-visible name, and excepting disambiguation will be equal to the local name of the element.(t_ElementDeclaration__id(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs|jS(ssThe L{basis.element} instance identifying the information associated with the element declaration. (t#_ElementDeclaration__elementBinding(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRscCs ||_|S(N(R(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt_setElementBindings cCs|jS(s"True iff the content model indicates that more than one element can legitimately belong to this use. This includes elements in particles with maxOccurs greater than one, and when multiple elements with the same NCName are declared in the same type. (t_ElementDeclaration__isPlural(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytisPluralscCsD||_||_||_||_||_tt|jdS(sCreate an ElementDeclaration instance. @param name: The name by which the element is referenced in the XML @type name: L{pyxb.namespace.ExpandedName} @param id: The Python name for the element within the containing L{pyxb.basis.binding.complexTypeDefinition}. This is a public identifier, albeit modified to be unique, and is usually used as the name of the element's inspector method or property. @type id: C{str} @param key: The string used to store the element value in the dictionary of the containing L{pyxb.basis.binding.complexTypeDefinition}. This is mangled so that it is unique among and is treated as a Python private member. @type key: C{str} @param is_plural: If C{True}, documents for the corresponding type may have multiple instances of this element. As a consequence, the value of the element will be a list. If C{False}, the value will be C{None} if the element is absent, and a reference to an instance of the type identified by L{pyxb.binding.basis.element.typeDefinition} if present. @type is_plural: C{bool} @param element_binding: Reference to the class that serves as the binding for the element. N(RRt_ElementDeclaration__keyRRRRR(RRRRt is_pluraltlocationR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs      cCs)|jrtd|jS|jjS(sReturn the default value for this element. For plural values, this is an empty collection. For non-plural values, it is C{None} unless the element has a default value, in which case it is that value. @todo: This should recursively support filling in default content, as when the plural list requires a non-zero minimum number of entries. R(RRRR(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs cCs |jrtd|jSdS(sReturn the reset value for this element. For plural values, this is an empty collection. For non-plural values, it is C{None}, corresponding to absence of an assigned element. RN(RRRR (R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt resetValues cCst||j|jS(sReturn the value for this use within the given instance. Note that this is the L{resetValue()}, not the L{defaultValue()}, if the element has not yet been assigned a value.(R RR(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR(scCst||j|j|S(s?Set the value for this use in the given element to its default.(R)RR(RR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR-scCs|dkr|j|S|jr:tj||n|jdk sOt|jjsmt |tj r|jj |d|j }nt ||j||jtj|||S(s4Set the value of this element in the given instance.RN(R R-t_isNilR%tContentInNilInstanceErrorRR2Rt forBindingR7tBINDRRR)Rt _addContentRR(RRR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR= s   !cCs,|jr|j||S|j||S(sZInvoke either L{set} or L{append}, depending on whether the element use is plural.(RRHR=(RRR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs cCs|jr!tj||n|jsEtj|||n|j|}|jjru|jj |}n|j ||j t j |||S(sAdd the given value as another instance of this element within the binding instance. @raise pyxb.StructuralBadDocumentError: invoked on an element use that is not plural (RR%RRtNonPluralAppendErrorR(RRRRRHRRR(RRR(tvalues((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRHs    c Cst|tjrt|j}|j|r9|j}n|dk sKt|jrlt j ||n|j |j |}|j }t|}t|tjrt||p|j|st jdt||fqn-t|tjrt||jr|}n|js9|j|ra|j|t jjjd|jn|j||nt|tjr|j |j |}|j|jj|nUt|t rxC|D]}|j!|||qWnt jdt||fdS(s<Convert the given value to DOM as an instance of this element. @param dom_support: Helper for managing DOM properties @type dom_support: L{pyxb.utils.domutils.BindingDOMSupport} @param parent: The DOM node within which this element should be generated. @type parent: C{xml.dom.Element} @param value: The content for this element. May be text (if the element allows mixed content), or an instance of L{basis._TypeBinding_mixin}. @raise pyxb.AbstractElementError: the binding to be used is abstract s7toDOM with implicit value type %s unrecoverable from %sR's)toDOM with unrecognized value type %s: %sN("R7RRFRt_substitutesFort_elementR R2tabstractR%tAbstractElementErrortcreateChildElementRRR'tcomplexTypeDefinitiont_RequireXSITypet LogicErrort STD_uniont _MemberTypestrequireXSITypeR.t namespacetXMLSchema_instancetcreateExpandedNameRrt _toDOM_cscRt string_typest appendChildtdocumenttcreateTextNodeRttoDOM( RR/tparentR(RR0telt_typetval_typeR((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR.s2     %$ ( cCs|rtj|jStj|jdg}|jrJ|jdn|j|jjd|tjdj |S(Ns: s MULTIPLE R?RC( RRDRRRRHRRGRzRJ(RR>R?RK((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRGWs cCst}||krt}nu|dk r0t}n`t|tjjrNt}nBy"|jj|dt}t}Wnt j t j fk rnX||fS(Nt_convert_string_values( R!R R R7R8R9R:RRR%tValidationErrort BindingError(RR(R_taccept((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR`s      cCsd|jt|fS(NsED.%s@%x(RR(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRxsN(RLRMRNRR RRRRRRRRRRR!RRRRR(R-R=RRHRR RGRR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs2       #      ) tWildcardcBsqeZdZdZdZdZdZd ZdZ dZ dZ dZ d Z d Zd Zd Zd ZRS(s!Placeholder for wildcard objects.s##anys##others##targetNamespaces##localcCs|jS(sA constraint on the namespace for the wildcard. Valid values are: - L{Wildcard.NC_any} - A tuple ( L{Wildcard.NC_not}, a L{namespace} instance ) - set(of L{namespace} instances) Namespaces are represented by their URIs. Absence is represented by C{None}, both in the "not" pair and in the set. (t_Wildcard__namespaceConstraint(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytnamespaceConstraints tskiptlaxtstrictcCs|jS(s:Indicate how this wildcard's contents should be processed.(t_Wildcard__processContents(R((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pytprocessContentsscCsi|dkrdSt|tjr=tjj|dt}nt|tjjset d|f|S(Ntcreate_if_missingsunexpected non-namespace %s( R R7RRR%R tNamespaceForURIR t NamespaceR2(Rtnsv((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyt__normalizeNamespaces  (cOs|d}t|tr9|d|j|df}n:t|trstg|D]}|j|^qR}n||_|d|_tt|jdS(st @keyword namespace_constraint: Required namespace constraint(s) @keyword process_contents: Requiredtnamespace_constraintiitprocess_contentsN( R7ttuplet_Wildcard__normalizeNamespaceR=RR!RRR(RRRtnsct_uri((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs  +  cCs=d}t|tjjrE|jdk rtjj|j}qnQt|t j r|j }|dk r|j j}q|j j}nt|tjjr|jrd}n|j|jkrtSt|jtr0|j\}}|j|ks t|dkrtS||kr,tStS||jkS(sReturn True iff the value is a valid match against this wildcard. Validation per U{Wildcard allows Namespace Name}. N(R R7R8R9R:t namespaceURIR%R R$RRFRRRrR%tisAbsentNamespacetNC_anyRR R*tNC_notR2R!(RRQR(tnsteltt_tconstrained_ns((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyRs,  !   N(RLRMRNR0R1tNC_targetNamespacetNC_localR RRtPC_skiptPC_laxt PC_strictR!R"R+RR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyR|s    ( RNtloggingtxml.domR8R%tpyxb.namespacetpyxb.utils.fact pyxb.bindingRtpyxb.utils.utilityt pyxb.utilsRt getLoggerRLRstcscRootRtobjectROtutilstfactSymbolMatch_mixinRRRt collectionstutilitytBackfillComparisonstMutableSequenceRRR(((sI/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/binding/content.pyts*       ^)@) ]