o hvO@sdZddlmZddlmZddlmZmZddlm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZddlmZddlmZGdd d eZGd d d eZGd d d eZdZGdddeZGdddeZ Gddde Z!eeZ"eeZ"dS)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_stringcsjeZdZdZdfdd ZddZfddZd d Zdd d ZdddZ ddZ ddZ ddZ Z 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 s@fdd|D}||\}}t||_dS)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. cs*i|]\}}|t|rt||n|qS)rr).0kvselfra/var/www/html/HyperOracle/crypto_trader/venv/lib/python3.10/site-packages/parsimonious/grammar.py >sz$Grammar.__init__..N)items_expressions_from_rulessuper__init__ default_rule)rrules more_rulesdecorated_custom_rulesexprsfirst __class__rrr"/s  zGrammar.__init__cCs|}|||_|S)zAReturn a new Grammar whose :term:`default rule` is ``rule_name``.)_copyr#)r rule_namenewrrrdefaultFs zGrammar.defaultcs*tt}tt|||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__r!r"rr#)rr-r)rrr+Ls z Grammar._copycCt|}t||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_rulestreerrrr Ys zGrammar._expressions_from_rulesrcC||jj||dS)zoParse some text with the :term:`default rule`. :arg pos: The index at which to start parsing pos)_check_default_ruler#r2rtextr:rrrr2isz Grammar.parsecCr8)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;r#matchr<rrrr>rsz Grammar.matchcCs|jstddS)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# RuntimeErrorrrrrr;|szGrammar._check_default_rulecsBjrjgng}|fddDddd|DS)zbReturn a rule string that, when passed to the constructor, would reconstitute the grammar.c3s|] }|jur|VqdSN)r#rexprrrr s  z"Grammar.__str__.. css|]}|VqdSr@)as_rulerArrrrCs)r#extendvaluesjoin)rr'rrr__str__szGrammar.__str__cCsdt|S)z8Return an expression that will reconstitute the grammar.z Grammar({!r}))formatstrrrrr__repr__szGrammar.__repr__)r)r)__name__ __module__ __qualname____doc__r"r.r+r r2r>r;rIrL __classcell__rrr)rrs    rc@eZdZdZddZdS) 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. cCr0r@)r1r2TokenRuleVisitorr4r5rrrr s z$TokenGrammar._expressions_from_rulesNrMrNrOrPr rrrrrSs rSc@rR)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. cCs|tddd}ttd|dd}t|dd}ttd|dd}ttd |d d}t|t|d d}ttd |d d} tddddd} t| |dd} ttd| tddd|dd} t|| | dd} t| | dd}t|| dd}ttd||dd}|f|j|_t|t|dd}ttd||dd}t|t|dd}t|||d d}t|||d!d}t|t|d"d}||}t |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_allrYliteral~z [ilmsuxa]*)rbregexatom quantifiedterm!not_termsequence/or_termoredrruler$) rr r rrrmembersrr2r3r4)r rule_syntaxr6rWrZr[r]r^r_r`rardrfrgrhrirkrlrnrorrpr$ rule_treerrrr s@     z,BootstrappingGrammar._expressions_from_rulesNrUrrrrrVs rVa+ # 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@s$eZdZdZdZddZddZdS) LazyReferencezMA lazy reference to a rule, which we resolve after grokking all the rulesrcCsnt}|} ||vrtd|jd|d||z|t|}Wn ty.t|wt|ts6|Sq)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. TzCircular Reference resolving r\.) setrrYaddrKKeyErrorr isinstancert)rrule_mapseencurrrr resolve_refs s   zLazyReference.resolve_refscCsd|S)Nzrrrrr_as_rhs&szLazyReference._as_rhsN)rMrNrOrPrYr}r~rrrrrts  rtc@seZdZdZeeedZej Z Z Z d&ddZ ddZdd Zd d Zd d ZddZddZddZddZddZddZddZddZddZd d!Zd"d#Zd$d%ZdS)'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. )?*+NcCs|pi|_d|_dS)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)rr6rrrr"6s  zRuleVisitor.__init__cCs|\}}}}}|S)zTreat a parenthesized subexpression as just its contents. Its position in the tree suffices to maintain its grouping semantics. r)rnode parenthesized left_parenr[r right_parenrrrvisit_parenthesized@szRuleVisitor.visit_parenthesizedcC |\}}|S)z5Turn a quantifier into just its symbol-matching node.r)rrr`symbolr[rrrvisit_quantifierIzRuleVisitor.visit_quantifiercCs|\}}z |j|j|WStyP|jddd}t|dkr-t|d}}n|dr7t|dnd}|drCt|dntd}t|||dYSw)N,rinf)minmax)quantifier_classesr=rxsplitlenintfloatr )rrrhrgr` min_match max_matchrrrvisit_quantifiedNs  zRuleVisitor.visit_quantifiedcC|\}}}t|Sr@)r )rrlookahead_term ampersandrir[rrrvisit_lookahead_term\ z RuleVisitor.visit_lookahead_termcCrr@)r)rrrk exclamationrir[rrrvisit_not_term`rzRuleVisitor.visit_not_termcCs|\}}}||_|S)z.Assign a name to the Expression and return it.rX)rrrpr^r]rrrr visit_ruleds zRuleVisitor.visit_rulecC|\}}t|g|RS)zfA parsed Sequence looks like [term node, OneOrMore node of ``another_term``s]. Flatten it out.)r)rrrlri other_termsrrrvisit_sequencejszRuleVisitor.visit_sequencecCrr@)r )rrro first_termrrrr visit_oredpszRuleVisitor.visit_oredcCs|\}}}|S)zReturn just the term from an ``or_term``. We already know it's going to be ored, from the containing ``ored``. r)rrrnslashr[rirrr visit_or_termts zRuleVisitor.visit_or_termcCs|\}}|jS)z#Turn a label into a unicode string.)r=)rrr^rYr[rrr visit_label}szRuleVisitor.visit_labelcCs|\}}t|S)zjStick a :class:`LazyReference` in the tree as a placeholder. We resolve them all later. )rt)rrr_r^ not_equalsrrrvisit_referenceszRuleVisitor.visit_referencec CsP|\}}}}|j}|j}t|d|vd|vd|vd|vd|vd|vd|vdS) zReturn a ``Regex`` expression.ILMSUXA)rblocale multilinercunicodeverboseascii)r=upperrdr)rrrftilderdflagsr[patternrrr visit_regexs   zRuleVisitor.visit_regexc Csjt|j}|jr*|j\}}|t|kr*ttd|jd|d|jdt|d |t|f|_t|S)z.r}rN) rupdater6listrhasattrr}ryrY)rr rules_listr[r$rzrYrprrr visit_ruless   zRuleVisitor.visit_rulesr@)rMrNrOrPr r rrr lift_childvisit_expression visit_term visit_atomr"rrrrrrrrrrrrrrrrrrrrr3*s*       r3c@s eZdZdZddZddZdS)rTznA visitor which builds expression trees meant to work on sequences of pre-lexed tokens rather than stringscCstt|jS)zrTurn a string literal into a ``TokenMatcher`` that matches ``Token`` objects by their ``type`` attributes.)rrr=)rrarrrrrsz(TokenRuleVisitor.visit_spaceless_literalcCs|\}}}}td)NzsRegexes do not make sense in TokenGrammars, since TokenGrammars operate on pre-lexed tokens rather than characters.)r)rrrfrrdrr[rrrrs zTokenRuleVisitor.visit_regexN)rMrNrOrPrrrrrrrTs rTN)#rP collectionsrtextwraprparsimonious.exceptionsrrparsimonious.expressionsrrrr r r r r rrrrrparsimonious.nodesrparsimonious.utilsrrrSrVrrrKrtr3rTr1rrrrs"  <  ~ @'':