f#]c@sWdZddlZddlZddlZddlmZddlmZeje Z de fdYZ de fdYZ d e fd YZd e fd YZd efdYZdefdYZdefdYZdefdYZdefdYZdfdYZdefdYZdefdYZdefdYZdefd YZd!efd"YZd#efd$YZd%efd&YZd'efd(YZd)efd*YZd+efd,YZ d-efd.YZ!d/eefd0YZ"d1efd2YZ#dS(3sThis module provides Finite Automata with Counters. FACs are type of state machine where a transition may include a constraint and a modification to a set of counters. They are used to implement regular expressions with numerical constraints, as are found in POSIX regexp, Perl, and XML schema. The implementation here derives from U{Regular Expressions with Numerical Constraints and Automata with Counters }, Dag Hovland, Lecture Notes in Computer Science, 2009, Volume 5684, Theoretical Aspects of Computing - ICTAC 2009, Pages 231-245. In what follows, this reference will be denoted B{HOV09}. A regular expression is directly translated into a term tree, where nodes are operators such as sequence, choice, and counter restrictions, and the leaf nodes denote symbols in the language of the regular expression. In the case of XML content models, the symbols include L{element declarations } and L{wildcard elements }. A numerical constraint node corresponds to an L{XML particle }, and choice and sequence nodes derive from L{model groups } of types B{choice} and B{sequence}. As suggested in U{The Membership Problem for Regular Expressions with Unordered Concatenation and Numerical Constraints } the B{all} content model can be translated into state machine using choice and sequence at the cost of a quadratic size explosion. Since some XML content models might have a hundred terms in an unordered catenation, this is not acceptable, and the implementation here optimizes this construct by creating a leaf node in the automaton which in turn contains sub-automata for each term, and permits an exit transition only when all the terms that are required have been completed. @note: In XSD 1.1 the restriction that terms in an B{all} model group occur at most once has been removed. Since the current implementation removes a completed term from the set of available terms, this will not work: instead the subconfiguration with its counter values must be retained between matches. iN(tsix(txrangetFACErrorcBseZRS((t__name__t __module__(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRDstInvalidTermTreeErrorcBs#eZdZdZdZdZRS(sException raised when a FAC term tree is not a tree. For example, a L{Symbol} node appears multiple times, or a cycle is detected.cGs,|\|_|_tt|j|dS(N(tparentttermtsuperRt__init__(tselftargs((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR RsN(RRt__doc__tNoneRRR (((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRGstUpdateApplicationErrorcBs#eZdZdZdZdZRS(sException raised when an unsatisfied update instruction is executed. This indicates an internal error in the implementation.cGs,|\|_|_tt|j|dS(N(tupdate_instructiontvaluesRRR (R R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR asN(RRR R RRR (((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRVstAutomatonStepErrorcBs8eZdZdZdZdZeeZdZ RS(sSymbol rejected by L{Configuration_ABC.step}. The exception indicates that the proposed symbol either failed to produce a transition (L{UnrecognizedSymbolError}) or produced multiple equally valid transitions (L{NondeterministicSymbolError}).cCs |jjS(sKA list of symbols that the configuration would accept in its current state.(t configurationtacceptableSymbols(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_acceptableuscGs,|\|_|_tt|j|dS(N(RtsymbolRRR (R R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR zsN( RRR R RRt#_AutomatonStepError__get_acceptabletpropertyt acceptableR (((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRes   tUnrecognizedSymbolErrorcBseZdZRS(s8L{Configuration.step} failed to find a valid transition.(RRR (((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR~stNondeterministicSymbolErrorcBseZdZRS(s1L{Configuration.step} found multiple transitions.(RRR (((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRstSymbolMatch_mixincBseZdZdZRS(sMix-in used by symbols to provide a custom match implementation. If a L{State.symbol} value is an instance of this mix-in, then it will be used to validate a candidate symbol for a match.cCs tdt|jfdS(Ns%s.match(tNotImplementedErrorttypeR(R R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pytmatchs(RRR R(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRstStatecBs@eZdZdedZdZdZdZe eZ dZ dZ e e Z dZdZe eZdZdZdZe eZdZdZe eZdZd Ze eZdZd Ze eZdd Zd ZdZ d Z!e e!Z"dZ#dZ$dZ%dZ&RS(sUA thin wrapper around an object reference. The state of the automaton corresponds to a position, or marked symbol, in the term tree. Because the same symbol may appear at multiple locations in the tree, and the distinction between these positions is critical, a L{State} wrapper is provided to maintain distinct values.cCs*||_| |_||_||_dS(sCreate a FAC state. @param symbol: The symbol associated with the state. Normally initialized from the L{Symbol.metadata} value. The state may be entered if, among other conditions, the L{match} routine accepts the proposed input as being consistent with this value. @param is_initial: C{True} iff this state may serve as the first state of the automaton. @param final_update: C{None} if this state is not an accepting state of the automaton; otherwise a set of L{UpdateInstruction} values that must be satisfied by the counter values in a configuration as a further restriction of acceptance. @param is_unordered_catenation: C{True} if this state has subautomata that must be matched to execute the unordered catenation of an L{All} node; C{False} if this is a regular symbol.N(t_State__symbolt_State__isInitialt_State__finalUpdatet_State__isUnorderedCatenation(R Rt is_initialt final_updatetis_unordered_catenation((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR s   cCs|jS(s4Link to the L{Automaton} to which the state belongs.(t_State__automaton(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_automatonscCs"|jdkst||_|S(s@Method invoked during automaton construction to set state owner.N(R'R tAssertionError(R t automaton((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt_set_automatons cCs|jS(sQApplication-specific metadata identifying the symbol. See also L{match}.(R (R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt __get_symbolscCs|jS(s Indicate whether the state has subautomata for unordered catenation. To reduce state explosion due to non-determinism, such a state executes internal transitions in subautomata until all terms have matched or a failure is discovered.(R#(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_isUnorderedCatenationscCs|jS(sA sequence of sub-automata supporting internal state transitions. This will return C{None} unless L{isUnorderedCatenation} is C{True}.(t_State__subAutomata(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_subAutomatascGs1|jdkst|js$t||_dS(N(R.R R)R#(R tautomata((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt_set_subAutomatascCs|jS(sCC{True} iff this state may be the first state the automaton enters.(R!(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_isInitialscCs|jdkrg}|jrt|t}|jdkrO|j|qxD|jD]6}x-|jD]"}|j|j|j qiWqYWn||_n|jS(sReturn the set of initial transitions allowing entry to the automata through this state. These are structurally-permitted transitions only, and must be filtered based on the symbol that might trigger the transition. The results are not filtered based on counter value, since this value is used to determine how the containing automaton might be entered. Consequently the return value is the empty set unless this is an initial state. The returned set is closed under entry to sub-automata, i.e. it is guaranteed that each transition includes a consuming state even if it requires a multi-element chain of transitions into subautomata to reach one.N( t!_State__automatonEntryTransitionsR R!t TransitiontsetR.tappendtinitialTransitionstchainTotmakeEnterAutomatonTransition(R t transitionstxittsatsaxit((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_automatonEntryTransitionss ' cCs|jS(sSReturn the update instructions that must be satisfied for this to be a final state.(R"(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_finalUpdatescCsv|jdk stt}g}|dkr9|j}nx0|D](}|jsXt}n|j|jq@W||fS(sFReturn the set of candidate transitions to enter a sub-automaton of this state. @param sub_automata: A subset of the sub-automata of this state which should contribute to the result. If C{None}, all sub-automata are used. @return: A pair C{(nullable, transitions)} where C{nullable} is C{True} iff there is at least one sub-automaton that is in an accepting state on entry, and C{transitions} is a list of L{Transition} instances describing how to reach some state in a sub-automaton via a consumed symbol. N(R.R R)tTruetnullabletFalsetextendR7(R t sub_automatat is_nullableR:R<((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pytsubAutomataInitialTransitionss      cCs&|jdkrtStj||jS(s:C{True} iff this state is an accepting state for the automaton. @param counter_values: Counter values that further validate whether the requirements of the automaton have been met. @return: C{True} if this is an accepting state and the counter values relevant at it are satisfied.N(R"R RBtUpdateInstructiont Satisfies(R tcounter_values((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt isAcceptingscCs|jS(s Definitions of viable transitions from this state. The transition set of a state is a set of L{Transition} nodes identifying a state reachable in a single step from this state, and a set of counter updates that must apply if the transition is taken. These transitions may not in themselves consume a symbol. For example, if the destination state represents a match of an L{unordered catenation of terms}, then secondary processing must be done to traverse into the automata for those terms and identify transitions that include a symbol consumption. @note: Although conceptually the viable transitions are a set, this implementation maintains them in a list so that order is preserved when automata processing becomes non-deterministic. PyXB is careful to build the transition list so that the states are attempted in the order in which they appear in the schema that define the automata. (t_State__transitionSet(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_transitionSet+scCsSg|_t}x:|D]2}||kr|j||jj|qqWdS(sMethod invoked during automaton construction to set the legal transitions from the state. The set of transitions cannot be defined until all states that appear in it are available, so the creation of the automaton requires that the association of the transition set be delayed. (Though described as a set, the transitions are a list where order reflects priority.) @param transition_set: a list of pairs where the first member is the destination L{State} and the second member is the set of L{UpdateInstruction}s that apply when the automaton transitions to the destination state.N(RKR5taddR6(R ttransition_settseenR;((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt_set_transitionSetDs      cCs/t|jtr"|jj|S|j|kS(s3Return C{True} iff the symbol matches for this state. This may be overridden by subclasses when matching by equivalence does not work. Alternatively, if the symbol stored in this node is a subclass of L{SymbolMatch_mixin}, then its match method will be used. Otherwise C{symbol} matches only if it is equal to the L{symbol} of this state. @param symbol: A candidate symbol corresponding to the expression symbol for this state. @return: C{True} iff C{symbol} is a match for this state. (t isinstanceR RR(R R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRZscCsdt|fS(NsS.%x(tid(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__str__lscCsg}|jtt|j|jdk rdt|jkrS|jdq|jddjtd|jndj|S(NisFinal (no conditions)s Final if %st cSs t|jS(N(tstrtcounterCondition(t_ui((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pytvss ( RCtmapRURKR"R tlenR6tjoin(R trv((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt_facTextos,N('RRR R RBR R't_State__get_automatonR+RR*R t_State__get_symbolRR#t!_State__get_isUnorderedCatenationtisUnorderedCatenationR.t_State__get_subAutomataR1t subAutomataR!t_State__get_isInitialt isInitialR3t%_State__get_automatonEntryTransitionstautomatonEntryTransitionsR"t_State__get_finalUpdatet finalUpdateRFRJRKt_State__get_transitionSett transitionSetRPRRSR](((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRsD                       tCounterConditioncBseZdZd ZdZeeZd ZdZ ee Z d Z dZ ee Z d dZdZdZdZdZRS( sA counter condition is a range limit on valid counter values. Instances of this class serve as keys for the counters that represent the configuration of a FAC. The instance also maintains a pointer to application-specific L{metadata}.cCs|jS(sQThe minimum legal value for the counter. This is a non-negative integer.(t_CounterCondition__min(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt __get_minscCs|jS(sThe maximum legal value for the counter. This is a positive integer, or C{None} to indicate that the counter is unbounded.(t_CounterCondition__max(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt __get_maxscCs|jS(sJA pointer to application metadata provided when the condition was created.(t_CounterCondition__metadata(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_metadatascCs||_||_||_dS(sCreate a counter condition. @param min: The value for L{min} @param max: The value for L{max} @param metadata: The value for L{metadata} N(RmRoRq(R tmintmaxtmetadata((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR s  cCs't|jt|jAt|jAS(N(thashRmRoRq(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__hash__scCs@|dk o?|j|jko?|j|jko?|j|jkS(N(R RmRoRq(R tother((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__eq__s cCs|j| S(N(Ry(R Rx((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__ne__scCs2dt||j|jdk r*|jp-dfS(Ns C.%x{%s,%s}t(RRRsRtR (R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRSsN(RRR R Rmt_CounterCondition__get_minRRsRot_CounterCondition__get_maxRtRqt_CounterCondition__get_metadataRuR RwRyRzRS(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRlys         RGcBseZdZd ZdZeeZd ZdZ ee Z d Z d Z dZ dZedZdZedZdZd Zd Zd ZRS( sSAn update instruction pairs a counter with a mutation of that counter. The instruction is executed during a transition from one state to another, and causes the corresponding counter to be incremented or reset. The instruction may only be applied if doing so does not violate the conditions of the counter it affects.cCs|jS(sA reference to the L{CounterCondition} identifying the counter to be updated. The counter condition instance is used as a key to the dictionary maintaining current counter values.(t$_UpdateInstruction__counterCondition(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_counterConditionscCs|jS(sKC{True} if the counter is to be incremented; C{False} if it is to be reset.(t_UpdateInstruction__doIncrement(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_doIncrementscCs0||_| |_|j|_|j|_dS(sCreate an update instruction. @param counter_condition: A L{CounterCondition} identifying a minimum and maximum value for a counter, and serving as a map key for the value of the corresponding counter. @param do_increment: C{True} if the update is to increment the value of the counter; C{False} if the update is to reset the counter. N(RRRst_UpdateInstruction__minRtt_UpdateInstruction__max(R tcounter_conditiont do_increment((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR s   cCsY||j}|jr8|jdk r8||jkr8tS|j rU||jkrUtStS(skImplement a component of definition 5 from B{HOV09}. The update instruction is satisfied by the counter values if its action may be legitimately applied to the value of its associated counter. @param counter_values: A map from L{CounterCondition}s to non-negative integers @return: C{True} or C{False} N(RRRR RBRR@(R RItvalue((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt satisfiedBys   cCs(x!|D]}|j|stSqWtS(scReturn C{True} iff the counter values satisfy the update instructions. @param counter_values: A map from L{CounterCondition} to integer counter values @param update_instructions: A set of L{UpdateInstruction} instances @return: C{True} iff all instructions are satisfied by the values and limits.(RRBR@(tclsRItupdate_instructionstpsi((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRHs cCs[|j|s!t||n||j}|jrD|d7}nd}|||j} of the L{consumingState}.(RR(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pytconsumedSymbolvscCst|jtrtSt|jtr4|j}n|jj|jksOt|j|sbt S|j r{|j j |StS(sCheck the transition update instructions against configuration counter values. This implementation follows layer changes, updating the configuration used as counter value source as necessary. @param configuration: A L{Configuration} instance containing counter data against which update instruction satisfaction is checked. @return: C{True} iff all update instructions along the transition chain are satisfied by their relevant configuration.( RQRt AutomatonR@t ConfigurationRR*R)t satisfiesRBRR(R R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRzs  cCs|j}t|trC|dk r1||}n|j|}n!t|trd|j|}ntj|j |j |j |j |dk|j dkr|S|j j||S(sApply the transitition to a configuration. This updates the configuration counter values based on the update instructions, and sets the new configuration state. @note: If the transition involves leaving a sub-automaton or creating a new sub-automaton, the returned configuration structure will be different from the one passed in. You should invoke this as:: cfg = transition.apply(cfg) @param configuration: A L{Configuration} of an executing automaton @param clone_map: A map from L{Configuration} to L{Configuration} reflecting the replacements made when the configuration for which the transition was calculated was subsequently cloned into the C{configuration} passed into this method. This is only necessary when the transition includes layer transitions. @return: The resulting configuration N(RRQRR tleaveAutomatonRtenterAutomatonRGRtupdateInstructionst_get_counterValuest _set_stateRRR(R Rt clone_mapR((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRs   cCsA|j stt||j|jd|j}||_|S(s Duplicate the state and chain the duplicate to a successor transition. This returns a new transition which applies the operation for this transition, then proceeds to apply the next transition in the chain. @note: The node that is invoking this must not have successor transitions. @param next_transition: A L{Transition} node describing a subsequent transition. @return: a clone of this node, augmented with a link to C{next_transition}.R(RR)RRRR(R tnext_transitionthead((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR8s$ cCsX|jdkst|jdks*tt||j|j}|jj|_|S(sReplicate the transition as a layer link into its automaton. This is used on initial transitions into sub-automata where a sub-configuration must be created and recorded.N(RR R)RRRRR*(R R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR9s cCsQt|j}x!|jD]}|t|N}qW|t|jAt|jAS(N(RvRRRR(R R\tui((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRwscCsR|dk oQ|j|jkoQ|j|jkoQ|j|jkoQ|j|jkS(N(R RRRR(R Rx((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRys  cCs|j| S(N(Ry(R Rx((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRzscCsg}t|jtr;|jdt|jjfn/t|jtrj|jdt|jn|jd|jf|j|jkr|jd|jj fn|jddj t t |j f|jr |jd|jt |jndj |S( Ns from A%x sin A%x s enter %s svia %s swith %ss ; s then R{(RQRRR6RRR*RRRRR[RYRURR(R R\((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRSs#)  N(RRR R Rt_Transition__get_destinationRRRt#_Transition__get_updateInstructionsRRt_Transition__get_nextTransitiontnextTransitionRt_Transition__get_layerLinkt layerLinkR RRRRR8R9RwRyRzRS(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR40s0            %    tConfiguration_ABCcBs eZdZdZdZRS(sTBase class for something that represents an L{Automaton} in execution. For deterministic automata, this is generally a L{Configuration} which records the current automaton state along with its counter values. For non-deterministic automata, this is a L{MultiConfiguration} which records a set of L{Configuration}s.cCs tdt|jfdS(s2Return the acceptable L{Symbol}s given the current configuration. This method extracts the symbol from all candidate transitions that are permitted based on the current counter values. Because transitions are presented in a preferred order, the symbols are as well.s%s.acceptableSymbolsN(RRR(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRscCs tdt|jfdS(sExecute an automaton transition using the given symbol. @param symbol: A symbol from the alphabet of the automaton's language. This is a Python value that should be accepted by the L{SymbolMatch_mixin.match} method of a L{State.symbol}. It is not a L{Symbol} instance. @return: The new configuration resulting from the step. @raises AutomatonStepError: L{UnrecognizedSymbolError} when no transition compatible with C{symbol} is available, and L{NondeterministicSymbolError} if C{symbol} admits multiple transitions and the subclass does not support non-deterministic steps (see L{MultiConfiguration}). @warning: If the step entered or left a sub-automaton the return value will not be the configuration that was used to execute the step. The proper pattern for using this method is:: cfg = cfg.step(sym) s%s.stepN(RRR(R R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pytsteps(RRR RR(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRs  RcBs=eZdZdZdZdZeeZdZ dZ dZ dZ ee Z dZdZeeZdZdZeeZdZdZdZeeZd Zd Zd Zd Zd ZddZdZdZdZ dZ!ddZ"ddZ#dZ$dZ%RS(s}The state of an L{Automaton} in execution. This combines a state node of the automaton with a set of counter values.cCs|jS(sThe state of the configuration. This is C{None} to indicate an initial state, or one of the underlying automaton's states.(t_Configuration__state(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt __get_state3scCsz||jkrdS|r.d|_d|_n||_|rv|jdk rv|jdksatt|j|_ndS(sInternal state transition interface. @param state: the new destination state @param is_layer_change: C{True} iff the transition inducing the state change involves a layer change. N(RR t _Configuration__subConfigurationt_Configuration__subAutomataRcR)R(R tstatetis_layer_change((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR8s    cCs|jS(N(t_Configuration__counterValues(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRYscCs|jS(N(t_Configuration__automaton(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR(]scCs|jS(sReference to configuration being executed in a sub-automaton. C{None} if no sub-automaton is active, else a reference to a configuration that is being executed in a sub-automaton. Sub-configurations are used to match sub-terms in an L{unordered catenation} term. A configuration may have at most one sub-configuration at a time, and the configuration will be removed and possibly replaced when the term being processed completes.(R(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_subConfigurationbs cCs|jS(s:Reference to the configuration for which this is a sub-configuration. C{None} if no super-automaton is active, else a reference to a configuration that is being executed in a super-automaton. The super-configuration relation persists for the lifetime of the configuration.(t"_Configuration__superConfiguration(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_superConfigurationqs cCs|jS(ssA set of automata that must be satisfied before the current state can complete. This is used in unordered catenation. Each sub-automaton represents a term in the catenation. When the configuration enters a state with sub-automata, a set containing references to those automata is assigned to this attribute. Subsequently, until all automata in the state are satisfied, transitions can only occur within an active sub-automaton, out of the active sub-automaton if it is in an accepting state, and into a new sub-automaton if no sub-automaton is active. (R(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR/~s cCst||_dS(N(RR(R R0((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR1scCs4|jdk stt|jjtd|jS(sCreate a transition back to the containing configuration. This is done when a configuration is in an accepting state and there are candidate transitions to other states that must be considered. The transition does not consume a symbol.RN(RR R)R4RR5(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pytmakeLeaveAutomatonTransitionscCs"|j|kstd|_|S(sExecute steps to leave a sub-automaton. @param sub_configuration: The configuration associated with the automata that has completed. @return: C{self}N(RR)R R(R tsub_configuration((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRs cCs\|jdkst|jdk s*t|jj|t||_||j_|jS(sExecute steps to enter a new automaton. The new automaton is removed from the set of remaining automata for the current state, and a new configuration created. No transition is made in that new configuration. @param automaton: The automaton to be entered @return: The configuration that executes the new automaton as a sub-configuration of C{self}.N(RR R)RtremoveRR(R R*((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRs  cCstj|j|jS(N(RGRHRR(R t transition((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRscCsP|j}d|_tt|jt|jd|_d|_d|_ dS(Ni(i( RR RtdicttziptcounterConditionsRZRRR(R tfac((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRs   ( c sj}g}dkr'd}nfd}fd}jdkrg|j|jnBjdk rjj rn t}jrjj j\}}|jt d|n|rxst |jj D]\j dk r|jqjj \}}|jt fd|qWjdk rjrjjj} |jt fd| qntt|t|ksttt |t ||S(sReturn list of viable transitions on C{symbol} The transitions that are structurally permitted from this state, in order, filtering out those transitions where the update instruction is not satisfied by the configuration counter values and optionally those for which the symbol does not match. @param symbol: A symbol through which a transition from this state is intended. A value of C{None} indicates that the set of transitions should ignore the symbol; candidates are still filtered based on the counter state of the configuration. @return: A list of L{Transition} instances permitted from the current configuration. If C{symbol} is not C{None}, transitions that would not accept the symbol are excluded. Any transition that would require an unsatisfied counter update is also excluded. Non-deterministic automata may result in a lits with multiple members. cSstS(N(R@(t_xit((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXscs|jjS(N(RR(R(R(sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXscs |jS(N(R(R(R (sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXscSs |jS(N(R9(R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXscsj|jS(N(R8R9(R(R;(sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXscs j|S(N(R8(t_sx(tlxit(sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXsN(RR RRCR7RRJR@RRFRYtfilterRkRR6RRRtcandidateTransitionsRZt frozensetR)R( R RRR:t match_filtert update_filtert include_localt sub_initialt_tsupxit((R RR;RsC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRs4    # %$cCs#g|jD]}|j^q S(N(RR(R R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRscCsh|j|}dt|kr3t||ndt|krWt||n|dj|S(Nii(RRZRRR(R RR:((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRs cCs |jdkS(s6Return C{True} iff no transitions have ever been made.N(RR (R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRe scCs|jdk r|jdk r2|jj r2tS|jdk rotjtj t d|jt sotSn|jj|j S|j jS(s:Return C{True} iff the automaton is in an accepting state.cSs|jS(N(RA(t_sa((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXsN(RR RRJRBRt functoolstreducetoperatortand_RYR@RRRA(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRJs'cCs ||_||_|jdS(N(RRR(R R*tsuper_configuration((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR s  cCsY|dkri}n|}x|jdk r9|j}qW|j|d}|j|S(scClone a configuration and its descendents. This is used for parallel execution where a configuration has multiple candidate transitions and must follow all of them. It clones the entire chain of configurations through multiple layers. @param clone_map: Optional map into which the translation from the original configuration object to the corresponding cloned configuration object can be reconstructed, e.g. when applying a transition that includes automata exits referencing superconfigurations from the original configuration. N(R Rt_clonetget(R Rtroot((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pytclone$s   cCs||kstt||j}|||<|j|_|jj|_||_|jdk r|j|_|j r|j j |||_ qn|S(N( R)RRRRtcopyRRR RR(R RRRx((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR:s     cCsId|jdjgtj|jD]\}}d||f^q"fS(Ns%s: %ss ; s%s=%u(RR[Rt iteritemsR(R t_ct_v((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRSGsN(&RRR R Rt_Configuration__get_stateRRRRRRt_Configuration__get_automatonR*Rt$_Configuration__get_subConfigurationtsubConfigurationRt&_Configuration__get_superConfigurationtsuperConfigurationRt_Configuration__get_subAutomataR1RcRRRRRRRRReRJR RRRS(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR,sD              B       tMultiConfigurationcBs8eZdZdZdZdZdZdZRS(s?Support parallel execution of state machine. This holds a set of configurations, and executes each transition on each one. Configurations which fail to accept a step are silently dropped; only if this results in no remaining configurations will L{UnrecognizedSymbolError} be raised. If a step admits multiple valid transitions, a configuration is added for each one. See L{pyxb.binding.content.AutomatonConfiguration} for an alternative solution which holds actions associated with the transition until the non-determinism is resolved.cCs|g|_dS(N(t#_MultiConfiguration__configurations(R R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR ZscCs1g}x$|jD]}|j|jqW|S(N(RRCR(R Rtcfg((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR]scCsg}x|jD]}|j|}dt|kr:qdt|kri|j|dj|qx<|D]4}i}|j|}|j|j||qpWqWdt|krt||ntt|t|kst||_|S(Nii( RRRZR6RRRRR)(R Rt next_configsRR:RRtccfg((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRcs  !$ cCs_g}xR|jD]G}|}x|jdk r:|j}qW|jr|j|qqW|S(sReturn the set of configurations that are in an accepting state. Note that some of the configurations may be within a sub-automaton; their presence in the return value is because the root configuration is also accepting.N(RRR RJR6(R t acceptingRtrcfg((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pytacceptingConfigurationsvs  N( RRR R RR RRR(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRJs     RcBseZdZd ZdZeeZd ZdZ ee Z d Z dZ ee Z d ZdZeeZd ZdZeeZd ZdZeeZd dZdZd ZRS( sRepresentation of a Finite Automaton with Counters. This has all the standard FAC elements, plus links to other states/automata as required to support the nested automata construct used for matching unordered catenation terms.cCs|jS(sThe set of L{State}s in the automaton. These correspond essentially to marked symbols in the original regular expression, or L{element declarations} in an XML schema. @note: These are conceptually a set and are stored that way. When an L{Automaton} is constructed the incoming states should be passed as a list so the calculated initial transitions are executed in a deterministic order.(t_Automaton__states(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt __get_statess cCs|jS(sThe set of L{CounterCondition}s in the automaton. These are marked positions in the regular expression, or L{particles} in an XML schema, paired with their occurrence constraints.(t_Automaton__counterConditions(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_counterConditionsscCs|jS(s3C{True} iff the automaton accepts the empty string.(t_Automaton__nullable(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_nullablescCs|jS(sgThe set of transitions that may be made to enter the automaton. These are full transitions, including chains into subautomata if an initial state represents a node with sub-automata. @note: As with L{State.transitionSet}, the set is represented as a list to preserve priority when resolving non-deterministic matches.(t_Automaton__initialTransitions(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_initialTransitionss cCs|jS(siThe L{State} instance for which this is a sub-automaton. C{None} if this is not a sub-automaton.(t_Automaton__containingState(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_containingStatescCs|jS(s8The set of L{State} members which can terminate a match.(t_Automaton__finalStates(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_finalStatessc Cst||_x|jD]}|j|qWt||_||_||_g}t}xI|D]A}|jr|j|j n|j dk rg|j |qgqgW||_ t||_dS(N(RRR+RRRR5ReRCRgRiR RMRR( R tstatestcounter_conditionsRAtcontaining_statetstR;tfnlts((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR s      cCs t|S(s:Return a new L{Configuration} instance for this automaton.(R(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pytnewConfigurationsc Csg}|jddjtd|j|jddjtt|jx|jD]}|jdk r_xptt|jD]V}|jdt||t |j|fdjt|j|j dqWq_q_W|jddjtt|j |jd d jgt d |jD]}d ||j f^q6|jd djtt|j|jdx.|jD]#}|jd||jfqWdj|S(Ns sigma = %sRTcSs t|jS(N(RUR(t_s((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXss states = %ssSA %s.%u is %x: s s s counters = %ss initial = %ss ; cSs|jS(N(Re(R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXss%s on %ssinitial transitions: %ssStates:s%s: %s(R6R[RYRRURcR RRZRRtsplitRRRR7R](R R\RtiR((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRSs)&[&I& !N(RRR R Rt_Automaton__get_statesRRRt!_Automaton__get_counterConditionsRRt_Automaton__get_nullableRARt"_Automaton__get_initialTransitionsR7Rt_Automaton__get_containingStatetcontainingStateRt_Automaton__get_finalStatest finalStatesR RRS(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRs,            tNodecBseZdZdZeZeZdZ dZ dZ dZ e e ZdZdZe eZdZdZdZe eZdZdZdZe eZd ZdZd Ze eZd Zd Zd Z dZ!dZ"dZ#e e#Z$dZ%dZ&e e&Z'e(dZ)e(dZ*e(dZ+dZ,e-e.ddZ/dZ0dZ1e e1Z2dZ3dZ4RS(s%Abstract class for any node in the term tree. In its original form a B{position} (C{pos}) is a tuple of non-negative integers comprising a path from a node in the term tree. It identifies a node in the tree. After the FAC has been constructed, only positions that are leaf nodes in the term tree remain, and the corresponding symbol value (Python instance) is used as the position. An B{update instruction} (C{psi}) is a map from positions to either L{Node.RESET} or L{Node.INCREMENT}. It identifies actions to be taken on the counter states corresponding to the positions in its domain. A B{transition} is a pair containing a position and an update instruction. It identifies a potential next node in the state and the updates that are to be performed if the transition is taken. A B{follow value} is a map from a position to a set of transitions that may originate from the pos. This set is represented as a Python list since update instructions are dicts and cannot be hashed. cKs|jd|_dS(sCreate a FAC term-tree node. @keyword metadata: Any application-specific metadata retained in the term tree for transfer to the resulting automaton.RuN(Rt_Node__metadata(R tkw((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR scOs&|jd|jt|||S(s0Create a deep copy of the node. All term-tree--related attributes and properties are replaced with deep clones. Other attributes are preserved. @param args: A tuple of arguments to be passed to the instance constructor. @param kw: A dict of keywords to be passed to the instance constructor. @note: Subclasses should pre-extend this method to augment the C{args} and C{kw} parameters as necessary to match the expectations of the C{__init__} method of the class being cloned.Ru(t setdefaultRuR(R R R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRscCs|jS(s;Application-specific metadata provided during construction.(R(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRr0scCs.|jdkr't|j|_n|jS(sThe I{first} set for the node. This is the set of positions leading to symbols that can appear first in a string matched by an execution starting at the node.N(t _Node__firstR Rt_first(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt __get_first6scCs tdt|jfdS(sAbstract method that defines L{first} for the subclass. The return value should be an iterable of tuples of integers denoting paths from this node through the term tree to a symbol.s%s.firstN(RRR(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRAscCs.|jdkr't|j|_n|jS(sThe I{last} set for the node. This is the set of positions leading to symbols that can appear last in a string matched by an execution starting at the node.N(t _Node__lastR Rt_last(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt __get_lastJscCs tdt|jfdS(sAbstract method that defines L{last} for the subclass. The return value should be an iterable of tuples of integers denoting paths from this node through the term tree to a symbol.s%s.lastN(RRR(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRUscCs(|jdkr!|j|_n|jS(s6C{True} iff the empty string is accepted by this node.N(t_Node__nullableR t _nullable(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR^scCs tdt|jfdS(ssAbstract method that defines L{nullable} for the subclass. The return value should be C{True} or C{False}.s %s.nullableN(RRR(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRescCs(|jdkr!|j|_n|jS(sThe I{follow} map for the node.N(t _Node__followR t_follow(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt __get_followlscCs tdt|jfdS(sAbstract method that defines L{follow} for the subclass. The return value should be a map from tuples of integers (positions) to a list of transitions, where a transition is a position and an update instruction.s %s.followN(RRR(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRsscCs1d|_d|_d|_d|_d|_dS(sjReset any term-tree state associated with the node. Any change to the structure of the term tree in which the node appears invalidates memoized first/follow sets and related information. This method clears all that data so it can be recalculated. It does not clear the L{metadata} link, or any existing structural data.N(R RRRRt_Node__counterPositions(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR{s     cCs|jd|||dS(sVUtility function for term tree processing. @param pre: a callable that, unless C{None}, is invoked at each node C{n} with parameters C{n}, C{pos}, and C{arg}, where C{pos} is the tuple of integers identifying the path from the node at on which this method was invoked to the node being processed. The invocation occurs before processing any subordinate nodes. @param post: as with C{pre} but invocation occurs after processing any subordinate nodes. @param arg: a value passed to invocations of C{pre} and C{post}.N((t _walkTermTree(R tpretposttarg((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt walkTermTreescCs tdt|jfdS(s>Abstract method implementing L{walkTermTree} for the subclass.s%s.walkTermTreeN(RRR(R tpositionR R!R"((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRscCs>|jdkr7i}|jdd|||_n|jS(s/A map from positions to nodes in the term tree.cSs|j||S(N(R(t_nt_pt_a((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXsN(t_Node__posNodeMapR R#(R tpnm((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_posNodeMaps  cCsU|jdkrNi}x*tj|jD]\}}|||Rt counter_maptncitcounterstsymR$R%RtsposRNtsrctphitdposRtdsttuisettcountertaction((R1R?R>R@sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR=sD#$ ".6   'cCsD|jdkr=g}|jdd|t||_n|jS(sImplement definition 13.1 from B{HOV09}. The return value is the set of all positions leading to L{NumericalConstraint} nodes for which either the minimum value is not 1 or the maximum value is not unbounded.cSs:t|to9d|jks-|jdk o9|j|S(Ni(RQRCRsRtR R6(R%R&R'((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRX sN(RR R#R(R tcpos((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt__get_counterPositionss   cCsMt}x7|jD],}||t| kr|j|qqWt|S(sImplement definition 13.2 from B{HOV09}. This is the subset of L{counterPositions} that occur along the path to C{pos}.(R5RBRZRMR(R R1R\RZ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRJs  c Csg}|jdt|fttj|j}|jddjttt|jj ||jddjtt|j |jddjtt|j |jddjtt|j x8|j D]-}|jd|j|j t|fqWx|D]}x|j|D]\}}|j|}g}xOtj|D]>\} } |jd| |jkrd pd t| fqaW|jd t||j t|d j|fq2WqWd j|S(sObtain a description of the FAC in text format. This is a diagnostic tool, returning first, last, and follow maps using positions.sr = %ss sym(r) = %sRTs first(r) = %ss last(r) = %ssC = %ss qI(%s) -> %ss%s %sRtrsts%s -%s-> %s ; %ss ; s (R6RURRRERFR[RYR,RRHRIRBRuRRM( R R\RR1RRRURNRVtuvtctu((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt _facToString s"2&&&+  6=N(5RRR R t _PrecedenceRBtRESETR@RMR RRt_Node__get_metadataRRuRt_Node__get_firstRHRRt_Node__get_lastRIRRt_Node__get_nullableRARRt_Node__get_followRFRRR#RR(t_Node__get_posNodeMapR,R+t_Node__get_nodePosMapt nodePosMapRR4R7R9RARRlR=Rt_Node__get_counterPositionsRBRJR`(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRsX                      4   t MultiTermNodecBsDeZdZdZdZeeZdZdZ dZ RS(s6Intermediary for nodes that have multiple child nodes.cCs|jS(s1The set of subordinate terms of the current node.(t_MultiTermNode__terms(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt __get_terms;scOs#tt|j|||_dS(sTerm that collects an ordered sequence of terms. The terms are provided as arguments. All must be instances of a subclass of L{Node}.N(RRlR Rm(R RLR((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR @scCs+td|j}tt|j|S(NcSs |jS(N(R(R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXIs(RYRmRRlR(R tcterms((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRHscCs|dk r||||nxAtt|jD]*}|j|j||f|||q5W|dk r||||ndS(N(R RRZRmR(R R$R R!R"R^((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRLs  ( N( RRR R Rmt_MultiTermNode__get_termsRRLR RR(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRl7s    RGcBs;eZdZdZdZdZdZdZRS(s0Intermediary for nodes that have no child nodes.cCsdgS(N(((R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRVscCsdgS(N(((R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXscCstS(N(RB(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRZscCsitd6S(N((R(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR\scCsB|dk r||||n|dk r>||||ndS(N(R (R R$R R!R"((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR_s  (RRR RRRRR(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRGTs     RCcBseZdZdZdZdZeeZdZ dZ ee Z dZ dZ ee ZdddZdZd Zd Zd Zd Zd ZdZRS(snA term with a numeric range constraint. This corresponds to a "particle" in the XML Schema content model.icCs|jS(N(t_NumericalConstraint__min(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRnmscCs|jS(N(t_NumericalConstraint__max(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRprscCs|jS(N(t_NumericalConstraint__term(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyt __get_termwsiicKs5tt|j|||_||_||_dS(sTerm with a numerical constraint. @param term: A term, the number of appearances of which is constrained in this term. @type term: L{Node} @keyword min: The minimum number of occurrences of C{term}. The value must be non-negative. @keyword max: The maximum number of occurrences of C{term}. The value must be positive (in which case it must also be no smaller than C{min}), or C{None} to indicate an unbounded number of occurrences.N(RRCR RsRqRr(R RRsRtR((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR {s  cCs%tt|j|j|j|jS(N(RRCRRsRqRr(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRscCs!g|jjD]}d|^q S(Ni(i(RsRH(R t_fc((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRscCs!g|jjD]}d|^q S(Ni(i(RsRI(R t_lc((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRscCsd|jkp|jjS(Ni(RqRsRA(R ((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRsc Cs)i}d}t|jj}xtj|jjD]\}}|j|||||<||kr4|j|x|jjD]}||}i}x+|jj |D]} |j ||| eZdZdZdZdZedZdZRS(sA term that is an unordered sequence of terms. Note that the inheritance structure for this node is unusual. It has multiple children when it is treated as a term tree, but is considered a leaf node when constructing an automaton. icOstt|j||dS(sTerm that collects an unordered sequence of terms. The terms are provided as arguments. All must be instances of a subclass of L{Node}.N(RRKR (R RLR((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyR DscCs%x|jD]}|js tSq WtS(N(RLRARBR@(R R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRKs cGsdt|kr|dSg}xett|D]Q}||}td|| ||d}|jt||j|q3Wt|S(s:Create a term tree that implements unordered catenation of the terms. This expansion results in a standard choice/sequence term tree, at the cost of quadratic state expansion because terms are L{cloned} as required to satisfy the tree requirements of the term tree. @param terms: The tuple of terms that are elements of an accepted sequence. @return: A term tree comprising a choice between sequences that connect each term to the unordered catenation of the remaining terms.iicSs |jS(N(R(R((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRXfs(RZRRYR6RtCreateTermTreeR(RRLt disjunctsRR/trem((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRQs "#cCsCtjdtjdjg|jD]}t|^q%dS(Ns&(t,R}(RR_R[RLRU(R t_t((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRSjs( RRR RaR RRRRS(((sC/data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/fac.pyRK:s   tSymbolcBs/eZdZdZdZdZdZRS(sVA leaf term that is a symbol. The symbol is represented by the L{metadata} field.icKs$||d:s>    8/=hIX1L3