'ivO,dZddlmZddlmZddlmZmZddlm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZddlmZddlmZGdd eZGd d eZGd d eZdZGddeZGddeZ Gdde Z!eeZ"eeZ"y)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)dedent) BadGrammarUndefinedLabel) LiteralRegexSequenceOneOf Lookahead QuantifierOptional 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||\}}t||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_rulessuper__init__ default_rule) selfrules more_ruleskvdecorated_custom_rulesexprsfirst __class__s E/var/www/br/venv/lib/python3.12/site-packages/parsimonious/grammar.pyrzGrammar.__init__/s"#((*",1 +a. 1a&a ?",",33E;QR u '! ",s%A7c:|j}|||_|S)zAReturn a new Grammar whose :term:`default rule` is ``rule_name``.)_copyr)r rule_namenews r'defaultzGrammar.defaultFsjjly> 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._copyLs;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_rulesYs*!!%(<(..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_rulerr2rtextr:s r'r2z Grammar.parseis,   "  &&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 r9)r;rmatchr<s r'r?z Grammar.matchrs,   "  &&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|]}|jywrE)as_rulerFrGs r'rHz"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}))formatstrrBs r'__repr__zGrammar.__repr__s%%c$i00r-))r)__name__ __module__ __qualname____doc__rr,r)rr2r?r;rPrT __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|SrE)r1r2TokenRuleVisitorr4r5s r'rz$TokenGrammar._expressions_from_ruless(!!%( -33D99r-NrVrWrXrYrr-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_allrfliteral~z [ilmsuxa]*)roregexatom quantifiedterm!not_termsequence/or_termoredrruler) rr rr rrmembersrr2r3r4)r rule_syntaxr6rdrgrhrjrkrlrmrnrqrsrtrurvrxryr{r|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'rbrbs 1.r-rba+ # 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?b?\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\""is / ~"u?r?b?'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'"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 = ~r"[*+?]|\{\d*,\d+\}|\{\d+,\d*\}|\{\d+\}" _ 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 eZdZdZdZdZdZy) LazyReferencezMA lazy reference to a rule, which we resolve after grokking all the rulesrUct}|} ||vrtd|jd|d|j| |t |}t|ts|SS#t $r t |wxYw)a Traverse the rule map following top-level lazy references, until we reach a cycle (raise an error) or a concrete expression. For example, the following is a circular reference: foo = bar baz = foo2 foo2 = foo Note that every RHS of a grammar rule _must_ be either a LazyReference or a concrete expression, so the reference chain will eventually either terminate or find a cycle. zCircular Reference resolving ri.) setrrfaddrSKeyErrorr isinstancer)rrule_mapseencurs r' resolve_refszLazyReference.resolve_refs sud{ #@ 1TFRS!TUU  *s3x(c=1  *$S)) *s A!!A6c d|zS)Nzr`rBs r'_as_rhszLazyReference._as_rhs&s &--r-N)rVrWrXrYrfrrr`r-r'rrs  D:.r-rceZdZdZeeedZejxZ xZ Z ddZ dZdZdZdZd Zd Zd Zd Zd ZdZdZdZdZdZdZdZy)r3zTurns 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|_d|_y)zConstruct. :arg custom_rules: A dict of {rule name: expression} holding custom rules which will take precedence over the others N)r6_last_literal_node_and_type)rr6s r'rzRuleVisitor.__init__6s).B+/(r-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_parenrhr right_parens r'visit_parenthesizedzRuleVisitor.visit_parenthesized@s 5B1 Az;r-c|\}}|S)z5Turn a quantifier into just its symbol-matching node.r`)rrrmsymbolrhs r'visit_quantifierzRuleVisitor.visit_quantifierIs  r-cf|\}} |j|j|S#t$r|jddjd}t |dk(rt |dx}}n3|drt |dnd}|drt |dn t d}t|||cYSwxYw)N,rinf)minmax)quantifier_classesr=rsplitlenintfloatr )rrrurtrm min_match max_matchs r'visit_quantifiedzRuleVisitor.visit_quantifiedNs%j B;4**:??;DA A B#2.44S9J:!#(+JqM(:: I2t t d|jd|d|jdt|d |t|f|_t |S)z(>?  + +#'#C#C IyD// -$>>*"YKv>O>T>T=UUWX\]jXkWlm)" ,=d=>Q+Q(}%%r-c|\}}|S)z6Pick just the literal out of a literal-and-junk combo.r`)rrrqrnrhs r' visit_literalzRuleVisitor.visit_literals&1  r-c|xs|S)a Replace childbearing nodes with a list of their children; keep others untouched. For our case, if a node has children, only the children are important. Otherwise, keep the node around for (for example) the flags of the regex rule. Most of these kept-around nodes are subsequently thrown away by the other visitor methods. We can't simply hang the visited children off the original node; that would be disastrous if the node occurred in more than one place in the tree. r`)rrrs r' generic_visitzRuleVisitor.generic_visits '4'r-c<|\}}td|D}|j|jt|j D]&\}}t |ds|j |||<(|t|tr|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|fywrErerLs r'rHz*RuleVisitor.visit_rules..sCT 40CsrrN) rupdater6listrhasattrrrrf)rr rules_listrhrrrfr}s r' visit_ruleszRuleVisitor.visit_ruless5 CUCC ))*x~~/0 =JD$t^,"&!2!28!<  ='t4#58==1J JDHJ Jr-rE)rVrWrXrYr rrrr lift_childvisit_expression visit_term visit_atomrrrrrrrrrrrrrrrrrr`r-r'r3r3*s (jyI1<1G1GGGzJ0 B , / $ 2& ! ( "Jr-r3ceZdZdZdZdZy)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=)rrnrs 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)rrrsrrqrrhs r'rzTokenRuleVisitor.visit_regexs"#( wq,- -r-N)rVrWrXrYrrr`r-r'r^r^s,E -r-r^N)#rY collectionsrtextwraprparsimonious.exceptionsrrparsimonious.expressionsrrr r r r r rrrrrrparsimonious.nodesrparsimonious.utilsrrr\rbrrSrr3r^r1r`r-r'rs$>+.{1k{1| :7 ::.7:.@$ N$.C$.NvJ+vJr -{ -"$K0 {# r-