":hJdZddlmZddlmZmZddlmZmZm Z m Z m Z m Z m Z mZmZmZmZmZddlmZddlmZGdd eZGd d eZGd d eZdZGddeZGddeZGddeZeeZeeZy)zA convenience which constructs expression trees from an easy-to-read syntax Use this unless you have a compelling reason not to; it performs some optimizations that would be tedious to do when constructing an expression tree by hand. ) OrderedDict) BadGrammarUndefinedLabel) LiteralRegexSequenceOneOf LookaheadOptional ZeroOrMore OneOrMoreNot TokenMatcher expression is_callable) NodeVisitor)evaluate_stringc\eZdZdZd fd ZdZfdZdZd dZd dZ dZ d Z d Z xZ S) GrammaraEA collection of rules that describe a language You can start parsing from the default rule by calling ``parse()`` directly on the ``Grammar`` object:: g = Grammar(''' polite_greeting = greeting ", my good " title greeting = "Hi" / "Hello" title = "madam" / "sir" ''') g.parse('Hello, my good sir') Or start parsing from any of the other rules; you can pull them out of the grammar as if it were a dictionary:: g['title'].parse('sir') You could also just construct a bunch of ``Expression`` objects yourself and stitch them together into a language, but using a ``Grammar`` has some important advantages: * Languages are much easier to define in the nice syntax it provides. * Circular references aren't a pain. * It does all kinds of whizzy space- and time-saving optimizations, like factoring up repeated subexpressions into a single object, which should increase cache hit ratio. [Is this implemented yet?] c |jDcic] \}}|t|r t|||n|"}}}|j||\}}tt ||j||_ycc}}w)ayConstruct a grammar. :arg rules: A string of production rules, one per line. :arg default_rule: The name of the rule invoked when you call :meth:`parse()` or :meth:`match()` on the grammar. Defaults to the first rule. Falls back to None if there are no string-based rules in this grammar. :arg more_rules: Additional kwargs whose names are rule names and values are Expressions or custom-coded callables which accomplish things the built-in rule syntax cannot. These take precedence over ``rules`` in case of naming conflicts. N)itemsrr_expressions_from_rulessuperr__init__ default_rule) selfrules more_ruleskvdecorated_custom_rulesexprsfirst __class__s g/var/www/html/turnos/venv/lib/python3.12/site-packages/ccxt/static_dependencies/parsimonious/grammar.pyrzGrammar.__init__.s"#((*",1 +a. 1a&a ?",",33E;QR u gt%ekkm4! ",s%A;c:|j}|||_|S)zAReturn a new Grammar whose :term:`default rule` is ``rule_name``.)_copyr)r rule_namenews r&defaultzGrammar.defaultEsjjly> ctjt}tt||j |j |_|S)zReturn a shallow copy of myself. Deep is unnecessary, since Expression trees are immutable. Subgrammars recreate all the Expressions from scratch, and AbstractGrammars have no Expressions. )r__new__rrrr)rr*r%s r&r(z Grammar._copyKs;oog& gs$TZZ\2,, r,c`tj|}t|j|S)aReturn a 2-tuple: a dict of rule names pointing to their expressions, and then the first rule. It's a web of expressions, all referencing each other. Typically, there's a single root to the web of references, and that root is the starting symbol for parsing, but there's nothing saying you can't have multiple roots. :arg custom_rules: A map of rule names to custom-coded rules: Expressions ) rule_grammarparse RuleVisitorvisitrr custom_rulestrees r&rzGrammar._expressions_from_rulesXs*!!%(<(..t44r,c\|j|jj||S)zoParse some text with the :term:`default rule`. :arg pos: The index at which to start parsing pos)_check_default_rulerr1rtextr9s r&r1z Grammar.parsehs,   "  &&t&55r,c\|j|jj||S)zParse some text with the :term:`default rule` but not necessarily all the way to the end. :arg pos: The index at which to start parsing r8)r:rmatchr;s r&r>z Grammar.matchqs,   "  &&t&55r,c2|js tdy)z7Raise RuntimeError if there is no default rule defined.zCan't call parse() on a Grammar that has no default rule. Choose a specific rule instead, like some_grammar['some_rule'].parse(...).N)r RuntimeErrorrs r&r:zGrammar._check_default_rule{s%   LM M!r,cjr jgng}|jfdjDdjd|DS)zbReturn a rule string that, when passed to the constructor, would reconstitute the grammar.c3>K|]}|jur|ywN)r).0exprrs r& z"Grammar.__str__..s&4d!2!224s c3<K|]}|jywrD)as_rulerErFs r&rGz"Grammar.__str__..s:D:s)rextendvaluesjoin)rr#s` r&__str__zGrammar.__str__sP(,'8'8""#b 4dkkm4 4yy:E:::r,c6djt|S)z8Return an expression that will reconstitute the grammar.z Grammar({!r}))formatstrrAs r&__repr__zGrammar.__repr__s%%c$i00r,))r)__name__ __module__ __qualname____doc__rr+r(rr1r>r:rOrS __classcell__)r%s@r&rrs68". 5 66M;1r,rceZdZdZdZy) TokenGrammarzA Grammar which takes a list of pre-lexed tokens instead of text This is useful if you want to do the lexing yourself, as a separate pass: for example, to implement indentation-based languages. c`tj|}t|j|SrD)r0r1TokenRuleVisitorr3r4s r&rz$TokenGrammar._expressions_from_ruless(!!%( -33D99r,NrUrVrWrXrr,r&r[r[s  :r,r[ceZdZdZdZy)BootstrappingGrammaraThe grammar used to recognize the textual rules that describe other grammars This grammar gets its start from some hard-coded Expressions and claws its way from there to an expression tree that describes how to parse the grammar description syntax. ctdd}ttd|d}t|d}tt d|d}ttd |d }t|t |d }ttd |d } tdddd} t| |d} tt d| tdd|d} t|| | d} t| | d}t|| d}tt d||d}|f|j z|_t|t|d}tt d||d}t|t|d}t|||d }t|||d!}t|t|d"}|j|}tj|S)#zReturn the rules for parsing the grammar definition syntax. Return a 2-tuple: a dict of rule names pointing to their expressions, and then the top-level expression for the first rule. z #[^\r\n]*commentnamez\s+meaninglessness_=equalsz[a-zA-Z_][a-zA-Z_0-9]*label referencez[*+?] quantifierzu?r?"[^"\\]*(?:\\.[^"\\]*)*"Tspaceless_literal) ignore_casedot_allreliteral~z [ilmsuxa]*)rnregexatom quantifiedterm!not_termsequence/or_termoredrruler) rr r r rrmembersrr1r2r3)r rule_syntaxr5rcrfrgrirjrkrlrmrprrrsrtrurwrxrzr{rr|r rule_trees r&rz,BootstrappingGrammar._expressions_from_ruless 95f w=NO S 1'#,98917KUCKkB eHoq|D !"A.2*.':<,ai@ |>% ' YV<dJ\B ZF3GCL$ C {T\\1 D)D/ C73<DyAi0v>44lC vz?IdO':KK , }""9--r,Nr^r_r,r&raras 1.r,raa # Ignored things (represented by _) are typically hung off the end of the # leafmost kinds of nodes. Literals like "/" count as leaves. rules = _ rule* rule = label equals expression equals = "=" _ literal = spaceless_literal _ # So you can't spell a regex like `~"..." ilm`: spaceless_literal = ~"u?r?\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\""is / ~"u?r?'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'"is expression = ored / sequence / term or_term = "/" _ term ored = term or_term+ sequence = term term+ not_term = "!" term _ lookahead_term = "&" term _ term = not_term / lookahead_term / quantified / atom quantified = atom quantifier atom = reference / literal / regex / parenthesized regex = "~" spaceless_literal ~"[ilmsuxa]*"i _ parenthesized = "(" _ expression ")" _ quantifier = ~"[*+?]" _ reference = label !equals # A subsequent equal sign is the only thing that distinguishes a label # (which begins a new rule) from a reference (which is just a pointer to a # rule defined somewhere else): label = ~"[a-zA-Z_][a-zA-Z_0-9]*" _ # _ = ~r"\s*(?:#[^\r\n]*)?\s*" _ = meaninglessness* meaninglessness = ~r"\s+" / comment comment = ~r"#[^\r\n]*" ceZdZdZdZdZy) LazyReferencezMA lazy reference to a rule, which we resolve after grokking all the rulesrTc d|zS)Nzr_rAs r&_as_rhszLazyReference._as_rhs s '$..r,N)rUrVrWrXrerr_r,r&rrs  D/r,rceZdZdZeeedZejxZ xZ Z ddZ dZdZdZdZd Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZy)r2zTurns a parse tree of a grammar definition into a map of ``Expression`` objects This is the magic piece that breathes life into a parsed bunch of parse rules, allowing them to go forth and parse other things. )?*+Nc|xsi|_y)zConstruct. :arg custom_rules: A dict of {rule name: expression} holding custom rules which will take precedence over the others N)r5)rr5s r&rzRuleVisitor.__init__s).Br,c|\}}}}}|S)zTreat a parenthesized subexpression as just its contents. Its position in the tree suffices to maintain its grouping semantics. r_)rnode parenthesized left_parenrgr right_parens r&visit_parenthesizedzRuleVisitor.visit_parenthesized"s 5B1 Az;r,c|\}}|S)z5Turn a quantifier into just its symbol-matching node.r_)rrrlsymbolrgs r&visit_quantifierzRuleVisitor.visit_quantifier+s  r,cJ|\}}|j|j|SrD)quantifier_classesr<)rrrtrsrls r&visit_quantifiedzRuleVisitor.visit_quantified0s(%j7t&&z7==r,c$|\}}}t|SrD)r )rrlookahead_term ampersandrurgs r&visit_lookahead_termz RuleVisitor.visit_lookahead_term4s+ 4r,c$|\}}}t|SrD)r)rrrw exclamationrurgs r&visit_not_termzRuleVisitor.visit_not_term8s' T14yr,c |\}}}||_|S)z.Assign a name to the Expression and return it.rd)rrr|rjrirs r& visit_rulezRuleVisitor.visit_rule<s$(!vz r,c$|\}}t|g|S)zfA parsed Sequence looks like [term node, OneOrMore node of ``another_term``s]. Flatten it out.)r )rrrxru other_termss r&visit_sequencezRuleVisitor.visit_sequenceBs%k+{++r,c$|\}}t|g|SrD)r )rrr{ first_termrs r& visit_oredzRuleVisitor.visit_oredHs"& KZ.+..r,c|\}}}|S)zReturn just the term from an ``or_term``. We already know it's going to be ored, from the containing ``ored``. r_)rrrzslashrgrus r& visit_or_termzRuleVisitor.visit_or_termLs !q$ r,c$|\}}|jS)z#Turn a label into a unicode string.)r<)rrrjrergs r& visit_labelzRuleVisitor.visit_labelUsayyr,c"|\}}t|S)zjStick a :class:`LazyReference` in the tree as a placeholder. We resolve them all later. )r)rrrkrj not_equalss r&visit_referencezRuleVisitor.visit_referenceZs &zU##r,c |\}}}}|jj}|j}t|d|vd|vd|vd|vd|vd|vd|vS) zReturn a ``Regex`` expression.ILMSUXA)rnlocale multilinerounicodeverboseascii)r<upperrpr)rrrrtilderpflagsrgpatterns r& visit_regexzRuleVisitor.visit_regexcsj#( wq   "//W#,%(E\(+u &)Ul&)Ul&)Ul$'5L 2 2r,c>tt|jS)z.s*%A)/&*%7%7&$%O%As ) isinstancerrRKeyErrorrrgetattraddtupler})rrrFrrj reffed_exprs`` ` r&rzRuleVisitor._resolve_refss dM *IE +&uo %%h TB BtY+D0@$%A37<<%A A K +$T** +s BBc|\}}td|Djjttfdj Dt |t r|r|djfSdfS)aCollate all the rules into a map. Return (map, default rule). The default rule is the first one. Or, if you have more than one rule of that name, it's the last-occurring rule of that name. (This lets you override the default rule when you extend a grammar.) If there are no string-based rules, the default rule is None, because the custom rules, due to being kwarg-based, are unordered. c38K|]}|j|fywrDrdrKs r&rGz*RuleVisitor.visit_rules..sCT 40Csc3\K|]#}|jj|f%ywrD)rer)rErFrrrs r&rGz*RuleVisitor.visit_rules..s1>#'!% 4+=+=hd+ST>s),rN)rupdater5setrMrlistre)rr rules_listrgrrrs` @@r& visit_ruleszRuleVisitor.visit_ruless5 CUCC ))*u>+3??+<>> 't4#58==1J JDHJ Jr,rD)rUrVrWrXr r rrr lift_childvisit_expression visit_term visit_atomrrrrrrrrrrrrrrrrrrr_r,r&r2r2 s (jyI1<1G1GGGzJ/ > , / $ 2@! ( : Jr,r2ceZdZdZdZdZy)r]znA visitor which builds expression trees meant to work on sequences of pre-lexed tokens rather than stringsc>tt|jS)zrTurn a string literal into a ``TokenMatcher`` that matches ``Token`` objects by their ``type`` attributes.)rrr<rs r&rz(TokenRuleVisitor.visit_spaceless_literalsO,=,B,BCDDr,c&|\}}}}td)NzsRegexes do not make sense in TokenGrammars, since TokenGrammars operate on pre-lexed tokens rather than characters.)r)rrrrrrprrgs r&rzTokenRuleVisitor.visit_regexs"#( wq,- -r,N)rUrVrWrXrrr_r,r&r]r]s,E -r,r]N) rX collectionsr exceptionsrr expressionsrrr r r r r rrrrrnodesrutilsrrr[rar~rRrr2r]r0r_r,r&rs$2"{1k{1| :7 ::.7:.@$ N/C/zJ+zJz -{ -"$K0 {# r,