o hA@s0dZddlmZddlmZmZmZmZddlZ ddl m Z m Z m Z ddlmZmZddlmZdd Zd d ZeZGd d d eZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZddZGdddeZ d(d!d"Z!d)d$d%Z"d(d&d'Z#dS)*zESubexpressions that make up a parsed grammar These do the parsing. ) defaultdict)getfullargspec isfunctionismethodismethoddescriptorN) ParseErrorIncompleteParseErrorLeftRecursionError)Node RegexNode) StrAndReprcs tttg}tfdd|DS)Ncsg|]}|qSr ).0 criterionvaluer e/var/www/html/HyperOracle/crypto_trader/venv/lib/python3.10/site-packages/parsimonious/expressions.py szis_callable..)rrrany)rcriteriar rr is_callables rcstr tdr jttj}tr|d8}|dkr"dn |dkr)dntd|Gfdd d t}||d S) aWTurn a plain callable into an Expression. The callable can be of this simple form:: def foo(text, pos): '''If this custom expression matches starting at text[pos], return the index where it stops matching. Otherwise, return None.''' if the expression matched: return end_pos If there child nodes to return, return a tuple:: return end_pos, children If the expression doesn't match at the given ``pos`` at all... :: return None If your callable needs to make sub-calls to other rules in the grammar or do error reporting, it can take this form, gaining additional arguments:: def foo(text, pos, cache, error, grammar): # Call out to other rules: node = grammar['another_rule'].match_core(text, pos, cache, error) ... # Return values as above. The return value of the callable, if an int or a tuple, will be automatically transmuted into a :class:`~parsimonious.Node`. If it returns a Node-like class directly, it will be passed through unchanged. :arg rule_name: The rule name to attach to the resulting :class:`~parsimonious.Expression` :arg grammar: The :class:`~parsimonious.Grammar` this expression will be a part of, to make delegating to other rules possible __func__TFz@Custom rule functions must take either 2 or 5 arguments, not %s.cs(eZdZfddZfddZdS)z#expression..AdHocExpressioncs^r||n||||}t|tr|d}}n t|tr$|\}}n|St|||||dSN)children) isinstanceinttupler )selftextposcacheerrorresultendrcallablegrammar is_simpler r_uncached_matchPs    z3expression..AdHocExpression._uncached_matchcs djS)Nz{custom function "%s"})__name__r )r(r r_as_rhs] z+expression..AdHocExpression._as_rhsN)r, __module__ __qualname__r+r.r r'r rAdHocExpressionOs r2)name) rhasattrrlenrargsr RuntimeError Expression)r( rule_namer)num_argsr2r r'r expressions) r;c@seZdZdZddgZd!ddZddZd d Zd d Zd dZ ddZ d"ddZ d"ddZ ddZ ddZddZddZddZd S)#r8z3A thing that can be matched against a piece of textr3identity_tuplecCs||_|jf|_dSN)r3r<)r r3r r r__init__oszExpression.__init__cC t|jSr>)hashr<r-r r r__hash__sr/zExpression.__hash__cCs||tSr>)_eq_check_cyclessetr otherr r r__eq__vszExpression.__eq__cCs ||k Sr>r rEr r r__ne__yr/zExpression.__ne__cCs.|t|t|f|j|juo|j|jkSr>)addid __class__r<r rFcheckedr r rrC|szExpression._eq_check_cyclescCs|Sr>r r rule_mapr r r resolve_refsszExpression.resolve_refsrcCs.|j||d}|jt|krt||j||S)zReturn a parse tree of ``text``. Raise ``ParseError`` if the expression wasn't satisfied. Raise ``IncompleteParseError`` if the expression was satisfied but didn't consume the full string. )r")matchr&r5r)r r!r"noder r rparseszExpression.parsecCs,t|}|||tt|}|dur||S)aReturn the parse tree matching this expression at the given position, not necessarily extending all the way to the end of ``text``. Raise ``ParseError`` if there is no match there. :arg pos: The index at which to start matching N)r match_corerdict)r r!r"r$rRr r rrQs  zExpression.matchcCs|t|}||vr||}nt||<|||||}||<|tur*t|d|d|durE||jkrE|js?t|jdddurE||_||_|S)aInternal guts of ``match()`` This is appropriate to call only from custom rules or Expression subclasses. :arg cache: The packrat cache:: {(oid, pos): Node tree matched by object `oid` at index `pos` ...} :arg error: A ParseError instance with ``text`` already filled in but otherwise blank. We update the error reporting info on this object as we go. (Sticking references on an existing instance is faster than allocating a new one for each expression that fails.) We return None rather than raising and catching ParseErrors because catching is slow. )r"exprNr3)rJ IN_PROGRESSr+r r"r3getattrrW)r r!r"r#r$ expr_cacherRr r rrTs  zExpression.match_corecCsd|jj|fS)Nz<%s %s>)rKr,as_ruler-r r r__str__szExpression.__str__cCsD|}|dr|dr|dd}|jr d|j|fS|S)zReturn the left- and right-hand sides of a rule that represents me. Return unicode. If I have no ``name``, omit the left-hand side. ()rrVz%s = %s)r.strip startswithendswithr3)r rhsr r rr[s  zExpression.as_rulecCsdd|jDS)zReturn an iterable of my unicode-represented children, stopping descent when we hit a named node so the returned value resembles the input rule.cSsg|] }|jp |qSr )r3r.rmr r rrsz/Expression._unicode_members..)membersr-r r r_unicode_memberszExpression._unicode_memberscCst)zfReturn the right-hand side of a rule that represents me. Implemented by subclasses. )NotImplementedErrorr-r r rr.szExpression._as_rhsNr=)r)r,r0r1__doc__ __slots__r?rBrGrHrCrPrSrQrTr\r[rfr.r r r rr8fs    5 r8cs8eZdZdZdgZd fdd ZddZdd ZZS) LiteralzFA string literal Use these if you can; they're the fastest. literalr=cs t|||_||f|_dSr>)superr?rmr<)r rmr3rKr rr?s zLiteral.__init__cCs*||j|rt||||t|jSdSr>)r`rmr r5)r r!r"r#r$r r rr+szLiteral._uncached_matchcCr@r>)reprrmr-r r rr.r/zLiteral._as_rhsri) r,r0r1rjrkr?r+r. __classcell__r r rorrls rlc@seZdZdZddZdS) TokenMatcherziAn expression matching a single token of a given type This is for use only with TokenGrammars. cCs&||j|jkrt||||dSdS)Nr)typermr )r token_listr"r#r$r r rr+szTokenMatcher._uncached_matchN)r,r0r1rjr+r r r rrr s rrcsDeZdZdZdgZ  d fdd ZddZd d Zd d ZZ S)RegexzAn expression that matches what a regex does. Use these as much as you can and jam as much into each one as you can; they're fast. rer=Fc snt|t||o tj|otjB|otjB|otjB|o tjB|o%tj B| o*tj B|_|j |jf|_ dSr>) rnr?rvcompileILMSUXAr3r<) r patternr3 ignore_caselocale multilinedot_allunicodeverboseasciiror rr?s zRegex.__init__cCsJ|j||}|dur#|}t|||||d|d}||_|SdS)z-Return length of match, ``None`` if no match.Nrr)rvrQspanr )r r!r"r#r$rdrrRr r rr++szRegex._uncached_matchcs,ddfddtdtdDS)zAReturn the textual equivalent of numerically encoded regex flags.ilmsuxar=c3s,|]}d|>@r|dndVqdS)rr=Nr )ribitsflagsr r 7s*z/Regex._regex_flags_from_bits..r)joinranger5)r rr rr_regex_flags_from_bits4s(zRegex._regex_flags_from_bitscCsd|jj||jjS)Nz~{!r}{})formatrvrrrr-r r rr.9s  z Regex._as_rhs)r=FFFFFFF) r,r0r1rjrkr?r+rr.rqr r rorrus  rucsBeZdZdZdgZfddZddZfddZd d ZZ S) Compoundz7An abstract expression which contains other expressionsrecst|dd||_dS)z)``members`` is a sequence of expressions.r3r=N)rnr?getre)r rekwargsror rr?Cs zCompound.__init__cstfdd|jD|_|S)Nc3s|]}|VqdSr>)rPrcrOr rrIsz(Compound.resolve_refs..)rrerNr rrrPHszCompound.resolve_refscsBt|o t|jt|jko tfddt|j|jDS)Nc3s4|]\}}t|t|fvr||VqdSr>)rJrC)rrdmorMr rrPs2z,Compound._eq_check_cycles..)rnrCr5reallziprLrorrrCLs zCompound._eq_check_cyclescCst|j|jfSr>)rArKr3r-r r rrBSrgzCompound.__hash__) r,r0r1rjrkr?rPrCrBrqr r rorr>s  rc@ eZdZdZddZddZdS)SequencezA series of expressions that must match contiguous, ordered pieces of the text In other words, it's a concatenation operator: each piece has to match, one after another. c Cs`|}g}|jD] }|||||}|durdS|||j|j} || 7}qt|||||Sr>)rerTappendr&startr ) r r!r"r#r$new_posrrdrRlengthr r rr+bs    zSequence._uncached_matchcCdd|S)N({0}) rrrfr-r r rr.ozSequence._as_rhsNr,r0r1rjr+r.r r r rrZs rc@r)OneOfzA series of expressions, one of which must match Expressions are tested in order from first to last. The first to succeed wins. cCsB|jD]}|||||}|durt||||j|gdSqdSr)rerTr r&)r r!r"r#r$rdrRr r rr+zs zOneOf._uncached_matchcCr)Nrz / rr-r r rr.rz OneOf._as_rhsNrr r r rrss rcsHeZdZdZdgZddfdd ZddZd d Zfd d ZZ S) LookaheadzSAn expression which consumes nothing, even if its contained expression succeeds negativityFnegativec s"tj|fi|t||_dSr>)rnr?boolr)r memberrrror rr?szLookahead.__init__cCs6|jd||||}|du|jkrt||||SdSNr)rerTrr )r r!r"r#r$rRr r rr+szLookahead._uncached_matchcCsd|jrdnd|dfS)N%s%s!&r)rrfr-r r rr.szLookahead._as_rhscst||o |j|jkSr>)rnrCrrLror rrCs zLookahead._eq_check_cycles) r,r0r1rjrkr?r+r.rCrqr r rorrsrcCs t|ddS)NTr)r)termr r rNots rcsReZdZdZddgZdedddfdd Zd d Zd d ZfddZ Z S) QuantifierzAAn expression wrapper like the */+/?/{n,m} quantifier in regexes.minmaxrinfr=)rrr3c s(tj|fd|i|||_||_dS)Nr3)rnr?rr)r rrrr3rror rr?s zQuantifier.__init__c Cs|}g}t|}||krIt||jkrI|jd||||}|dur#n&|||j|j} t||jkr:| dkr:n|| 7}||krIt||jkst||jkrXt|||||SdSr) r5rrerTrr&rrr ) r r!r"r#r$rrsizerRrr r rr+s    zQuantifier._uncached_matchcCs|jdkr |jdkr d}n>|jdkr|jtdkrd}n/|jdkr+|jtdkr+d}n |jtdkr8d|j}n|jdkrCd|j}nd |j|jf}d |d|fS) Nrr?r*+z{%d,}z{,%d}z{%d,%d}r)rrfloatrf)r qualifierr r rr.s   zQuantifier._as_rhscs&t||o|j|jko|j|jkSr>)rnrCrrrLror rrCs   zQuantifier._eq_check_cycles) r,r0r1rjrkrr?r+r.rCrqr r rorrsrr=cCst||dtddS)Nrrr3rrrrrr3r r r ZeroOrMorerrrcCst|||tddS)Nrrr)rr3rr r r OneOrMorerrcCst||dddS)Nrrr)rrr r rOptionalsrri)r=r)$rj collectionsrinspectrrrrregexrvparsimonious.exceptionsrrr parsimonious.nodesr r parsimonious.utilsr rr;objectrXr8rlrrrurrrrrrrrrr r r rs0  L ( 0