E#iJSrSSKJr SSKJrJr SSKJrJrJ r J r J r J r J r JrJrJrJrJr SSKJr SSKJr "SS \5r"S S \5r"S S \5rSr"SS\5r"SS\5r"SS\5r\"\5r\"\5rg)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_stringcn^\rSrSrSrS U4SjjrSrU4SjrSrSSjr SSjr S r S r S r S rU=r$)GrammaraA 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 >UR5VVs0sH$up4U[U5(a [XCU5OU_M& nnnURX5upg[[ U]UR55 Xplgs snnf)a)Construct 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/home/james-whalen/.local/lib/python3.13/site-packages/ccxt/static_dependencies/parsimonious/grammar.pyrGrammar.__init__.sz"#((*",* +a.. 1&a ?* ",33ER  gt%ekkm4! ",s+A>c8UR5nX!UlU$)zAReturn a new Grammar whose :term:`default rule` is ``rule_name``.)_copyr)r rule_namenews r'defaultGrammar.defaultEsjjl> c>[R[5n[[U]UR 55 UR UlU$)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* Grammar._copyKs;oog& gs$TZZ\2,, r/c`[RU5n[U5RU5$)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'rGrammar._expressions_from_rulesXs*!!%(<(..t44r/cTUR5 URRXS9$)z_Parse some text with the :term:`default rule`. :arg pos: The index at which to start parsing pos)_check_default_rulerr5rtextr>s r'r5 Grammar.parsehs*   "  &&t&55r/cTUR5 URRXS9$)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 r=)r?rmatchr@s r'rD Grammar.matchqs*   "  &&t&55r/c<UR(d [S5eg)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?Grammar._check_default_rule{s%   LM M!r/c^TR(a TR/O/nURU4SjTR555 SRSU55$)zZReturn a rule string that, when passed to the constructor, would reconstitute the grammar.c3J># UHnUTRLdMUv M g7fNr).0exprrs r' "Grammar.__str__..s&4md!2!22Tms# # c3@# UHoR5v M g7frL)as_rulerNrOs r'rPrQs:EDEs)rextendvaluesjoin)rr$s` r'__str__Grammar.__str__sP(,'8'8""#b 4dkkm4 4yy:E:::r/c6SR[U55$)z8Return an expression that will reconstitute the grammar.z Grammar({!r}))formatstrrHs r'__repr__Grammar.__repr__s%%c$i00r/rM))r)__name__ __module__ __qualname____firstlineno____doc__rr-r*rr5rDr?rYr^__static_attributes__ __classcell__)r&s@r'rrs;8". 5 66M;11r/rc\rSrSrSrSrSrg) 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`[RU5n[U5RU5$rL)r4r5TokenRuleVisitorr7r8s r'r$TokenGrammar._expressions_from_ruless(!!%( -33D99r/Nrarbrcrdrerrfrnr/r'riris  :r/ric\rSrSrSrSrSrg)BootstrappingGrammarzThe 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. c  [SSS9n[[S5USS9n[USS9n[[ S5USS9n[[S 5US S9n[U[ U5S S9n[[S 5US S9n [SSSSS9n [XSS9n [[ S5U [SSS9USS9n [XU SS9n [XSS9n[XSS9n[[ S5XSS9nU4UR -Ul[U[U5SS9n[[ S5X_SS9n[U[U5SS9n[UUUS S9n[XvUS!S9n[U[U5S"S9nURU5n[5RU5$)#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_allrvliteral~z [ilmsuxa]*)rregexatom quantifiedterm!not_termsequence/or_termoredrruler) rr r r rrmembersrr5r6r7)r rule_syntaxr9rtrwrxrzr{r|r}r~rrrrrrrrrrrr rule_trees r'r,BootstrappingGrammar._expressions_from_ruless 95f w=NO S 1'#,98917KUCKkB eHoq|D !"A.2*.':<,i@ |>% ' YV<d\B ZF3GCL$ C {T\\1 D)D/ C73<yAi0v>44lC z?IdO':KK , }""9--r/rnNrornr/r'rqrqs 1.r/rqa # 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]*" c"\rSrSrSrSrSrSrg) LazyReferenceizIA lazy reference to a rule, which we resolve after grokking all the rulesr`c SU-$)NzrnrHs r'_as_rhsLazyReference._as_rhs s '$..r/rnN)rarbrcrdrervrrfrnr/r'rrs  D/r/rc\rSrSrSr\\\S.r\ R=r =r r SSjrSrSrSrS rS rS rS rS rSrSrSrSrSrSrSrSrSrSr g)r6i zTurns 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$U=(d 0Ulg)zConstruct. :arg custom_rules: A dict of {rule name: expression} holding custom rules which will take precedence over the others Nr9)rr9s r'rRuleVisitor.__init__s).Br/cUup4pVnU$)zTreat a parenthesized subexpression as just its contents. Its position in the tree suffices to maintain its grouping semantics. rn)rnode parenthesized left_parenrxr right_parens r'visit_parenthesizedRuleVisitor.visit_parenthesized"s 5B1 zr/cUup4U$)z5Turn a quantifier into just its symbol-matching node.rn)rrr}symbolrxs r'visit_quantifierRuleVisitor.visit_quantifier+s  r/cHUup4URUR"U5$rL)quantifier_classesrA)rrrrr}s r'visit_quantifiedRuleVisitor.visit_quantified0s$%&&z7==r/c"Uup4n[U5$rL)r )rrlookahead_term ampersandrrxs r'visit_lookahead_term RuleVisitor.visit_lookahead_term4s+ r/c"Uup4n[U5$rL)r)rrr exclamationrrxs r'visit_not_termRuleVisitor.visit_not_term8s' 14yr/cUup4nX5lU$)z.Assign a name to the Expression and return it.ru)rrrr{rzrs r' visit_ruleRuleVisitor.visit_rule<s$(!zr/c"Uup4[U/UQ76$)z^A parsed Sequence looks like [term node, OneOrMore node of ``another_term``s]. Flatten it out.)r )rrrr other_termss r'visit_sequenceRuleVisitor.visit_sequenceBs%+{++r/c"Uup4[U/UQ76$rL)r )rrr first_termrs r' visit_oredRuleVisitor.visit_oredHs"& Z.+..r/cUup4nU$)zqReturn just the term from an ``or_term``. We already know it's going to be ored, from the containing ``ored``. rn)rrrslashrxrs r' visit_or_termRuleVisitor.visit_or_termLs !$ r/c"Uup4UR$)z#Turn a label into a unicode string.)rA)rrr{rvrxs r' visit_labelRuleVisitor.visit_labelUsyyr/c Uup4[U5$)zZStick a :class:`LazyReference` in the tree as a placeholder. We resolve them all later. )r)rrr|r{ not_equalss r'visit_referenceRuleVisitor.visit_referenceZs &U##r/c Uup4pVURR5nURn[USU;SU;SU;SU;SU;SU;SU;S9$) zReturn a ``Regex`` expression.ILMSUXA)rlocale multilinerunicodeverboseascii)rAupperrr)rrrtilderflagsrxpatterns r' visit_regexRuleVisitor.visit_regexcsf#(    "//W#,%(E\(+u &)Ul&)Ul&)Ul$'5L 2 2r/c>[[UR55$)z# UHnTRTUT5v M g7frL) _resolve_refs)rNmemberdonerule_maprs r'rP,RuleVisitor._resolve_refs..s+%A3?&*%7%7&$%O%O3?s #) isinstancerr]KeyErrorrrgetattraddtupler)rrrOrr{ reffed_exprs`` ` r'rRuleVisitor._resolve_refss dM * *IE +&uo %%h TB BtY++D0@$%A37<<%A A K +$T** +s BB$c.^^^Uup4[SU55mTRTR5 [5m[UUU4SjTR 555mT[ U[ 5(aU(aTUSR4$S4$)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. c3<# UHoRU4v M g7frLrurUs r'rP*RuleVisitor.visit_rules..sCUT 40Usc3b># UH$nURTRTUT54v M& g7frL)rvr)rNrOrrrs r'rPrs0>+<4!% 4+=+=hd+ST++3??+<>> 't44#58==1J JDHJ Jr/rrL)!rarbrcrdrer r rrr lift_childvisit_expression visit_term visit_atomrrrrrrrrrrrrrrrrrrrfrnr/r'r6r6 s (jyI1<1G1GGGzJ/ > , / $ 2@! ( : Jr/r6c$\rSrSrSrSrSrSrg)rlizjA visitor which builds expression trees meant to work on sequences of pre-lexed tokens rather than stringsc>[[UR55$)zjTurn a string literal into a ``TokenMatcher`` that matches ``Token`` objects by their ``type`` attributes.)rrrArs r'r(TokenRuleVisitor.visit_spaceless_literalsO,=,B,BCDDr/c"Uup4pV[S5e)NzsRegexes do not make sense in TokenGrammars, since TokenGrammars operate on pre-lexed tokens rather than characters.)r)rrrrrrrxs r'rTokenRuleVisitor.visit_regexs#( ,- -r/rnN)rarbrcrdrerrrfrnr/r'rlrls,E -r/rlN) re collectionsr exceptionsrr expressionsrrr r r r r rrrrrnodesrutilsrrrirqrr]rr6rlr4rnr/r'rs$2"{1k{1| :7 ::.7:.@$ N/C/zJ+zJz -{ -"$K0 {# r/