":hAvdZddlmZmZmZmZddlZddlmZm Z ddl m Z m Z ddl mZeZdZd ZGd d eZGd d eZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGd d!eZy)"zESubexpressions that make up a parsed grammar These do the parsing. )getfullargspec isfunctionismethodismethoddescriptorN) ParseErrorIncompleteParseError)Node RegexNode) StrAndReprcltttg}t|Dcgc] }|| c}Scc}wN)rrrany)valuecriteria criterions k/var/www/html/turnos/venv/lib/python3.12/site-packages/ccxt/static_dependencies/parsimonious/expressions.py is_callablers-H&89H (;Y % ; <<;s1ctrtdr jtt j }t r|dz}|dk(rdn|dk(rdntd|zGfdd t}|| S) a3Turn 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:`~.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:`~.Expression` :arg grammar: The :class:`~.Grammar` this expression will be a part of, to make delegating to other rules possible __func__rTFz@Custom rule functions must take either 2 or 5 arguments, not %s.c&eZdZfdZfdZy)#expression..AdHocExpressionc r ||n |||| }t|tr|d}}nt|tr|\}}n|St|||||SNchildren) isinstanceinttupler ) selftextposcacheerrorresultendrcallablegrammar is_simples r_uncached_matchz3expression..AdHocExpression._uncached_matchQsf-6htS)tS%@ &#& &XFE* & X dCx@ @c"djzS)Nz{custom function "%s"})__name__)r"r)s r_as_rhsz+expression..AdHocExpression._as_rhs^s+h.?.?? ?r-N)r/ __module__ __qualname__r,r0)r)r*r+srAdHocExpressionrPs A @r-r3name) rhasattrrlenrargsr RuntimeError Expression)r) rule_namer*num_argsr3r+s` ` @r expressionr=sR(#*(E$$>(+001HA 1} Q 02:;< <@@*@"  **r-c`eZdZdZddgZddZdZdZdZddZ dd Z d Z d Z d Z d ZdZy)r:z3A thing that can be matched against a piece of textr5identity_tuplec6||_|jf|_yr)r5r?)r"r5s r__init__zExpression.__init__ms #yymr-c,t|jSr)hashr?r"s r__hash__zExpression.__hash__qsD''((r-cdt||jxr|j|jk(Sr)r __class__r?r"others r__eq__zExpression.__eq__ts)%0`T5H5HEL`L`5``r-c||k( SrrHs r__ne__zExpression.__ne__wsEM""r-c|j||}|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(r7r )r"r#r$nodes rparsezExpression.parsezs>zz$Cz( 88c$i &tTXXt< < r-cLt|}|j||i|}|||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 )r match_core)r"r#r$r&rPs rrOzExpression.matchs14 tS"e4 <K r-ct|}|j||ft}|tur|j||||x}|||f<|@||jk\r1|j st |jdd||_||_|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. Nr5)idgetMARKERr,r$r5getattrexpr)r"r#r$r%r&expr_idrPs rrSzExpression.match_cores@T(yy'30 6>+/+?+?@C@E@E,G GD5'3( F EJEI r-cXd|jjd|jdS)N< >)rGr/as_rulerDs r__str__zExpression.__str__s" NN # # LLN r-c|jj}|jdr|jdr|dd}|jr|jd|S|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. ()rz = )r0strip startswithendswithr5)r"rhss rr_zExpression.as_rulesT lln""$ >># 3<<#4a)C26))dii-DDr-cx|jDcgc] }|jxs|j"c}Scc}w)zReturn an iterable of my unicode-represented children, stopping descent when we hit a named node so the returned value resembles the input rule.)membersr5r0)r"ms r_unicode_memberszExpression._unicode_memberss.26>A&199;&>>>s%7ct)zfReturn the right-hand side of a rule that represents me. Implemented by subclasses. )NotImplementedErrorrDs rr0zExpression._as_rhss "!r-N)r)r/r1r2__doc__ __slots__rArErJrMrQrOrSr`r_rlr0rLr-rr:r:dsL= )*I,)a#  2h E? "r-r:c6eZdZdZdgZdfd ZdZdZxZS)LiteralzFA string literal Use these if you can; they're the fastest. literalcLtt| |||_||f|_yr)superrtrArur?)r"rur5rGs rrAzLiteral.__init__s% gt%d+ #Wor-c |j|j|r$t||||t|jzSyr)rfrur r7)r"r#r$r%r&s rr,zLiteral._uncached_matchs8 ??4<< -dCs4<z/Regex._regex_flags_from_bits..+s(a1Q$uQU|B>asr)joinranger7)r"rrs `@r_regex_flags_from_bitszRegex._regex_flags_from_bits(s1wwaaQTUZQ[^_Q_H`aaar-cdj|jj|j|jjS)Nz~{!r}{})formatrrrrrDs rr0z Regex._as_rhs-s7 $ ; ;DGGMM JL Lr-)rpFFFFFFF) r/r1r2rqrrrAr,rr0r|r}s@rrr s- ICHUZ 3b Lr-rc4eZdZdZdgZfdZdZdZxZS)Compoundz7An abstract expression which contains other expressionsrjcZtt| |jdd||_y)z)``members`` is a sequence of expressions.r5rpN)rwrrArVrj)r"rjkwargsrGs rrAzCompound.__init__7s$ h&vzz&"'=> r-cDt|j|jfSr)rCrGr5rDs rrEzCompound.__hash__<sT^^TYY/00r-ct||jxr4|j|jk(xr|j|jk(Sr)rrGr5rjrHs rrJzCompound.__eq__Bs? udnn - * II # * LLEMM ) +r-) r/r1r2rqrrrArErJr|r}s@rrr2sA I 1 +r-rceZdZdZdZdZy)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|}d}g}|jD]N}|j||||} | y|j| | j| jz } || z }|| z }Pt |||||z|SNr)rjrSappendr(startr ) r"r#r$r%r&new_poslength_of_sequencerrkrPlengths rr,zSequence._uncached_matchQs )A<<gue)>)@ABBr-Nr/r1r2rqr,r0rLr-rrrIs ICr-rceZdZdZdZdZy)OneOfzA series of expressions, one of which must match Expressions are tested in order from first to last. The first to succeed wins. c|jD]5}|j||||}|t||||j|gcSyrrjrSr r()r"r#r$r%r&rkrPs rr,zOneOf._uncached_matchksJ HA<<c5%8DD$TXXGG  Hr-c^djdj|jS)Nrz / rrDs rr0z OneOf._as_rhsrs#v{{4+@+@+BCDDr-NrrLr-rrrds HEr-rceZdZdZdZdZy) LookaheadzSAn expression which consumes nothing, even if its contained expression succeedscf|jdj||||}|t||||SyrrjrSr r"r#r$r%r&rPs rr,zLookahead._uncached_match~s<||A))$UEB  dC- - r-c.d|jdzS)Nz&%srrlrDs rr0zLookahead._as_rhs--/222r-NrrLr-rrrvs. 3r-rceZdZdZdZdZy)NotzAn expression that succeeds only if the expression within it doesn't In any case, it never consumes any characters; it's a negative lookahead. cf|jdj||||}|t||||Syrrrs rr,zNot._uncached_matchs=||A))$UEB <dC- - r-c.d|jdzS)Nz!%srrrDs rr0z Not._as_rhss--/222r-NrrLr-rrrs .3r-rceZdZdZdZdZy)OptionalzAn expression that succeeds whether or not the contained one does If the contained expression succeeds, it goes ahead and consumes what it consumes. Otherwise, it consumes nothing. c|jdj||||}|t||||St||||j|gS)Nrrrrs rr,zOptional._uncached_matchsT||A))$UEB.2lT4c* BT4dhh$@ Br-c.d|jdzS)Nz%s?rrrDs rr0zOptional._as_rhsrr-NrrLr-rrrs B 3r-rceZdZdZdZdZy) ZeroOrMorez7An expression wrapper like the * quantifier in regexes.c|}g} |jdj||||}||j|jz st |||||S|j |||j|jz z }yr)rjrSr(rr r)r"r#r$r%r&rrrPs rr,zZeroOrMore._uncached_matchs|<<?--dGUEJD|DHHtzz$9D$Wh?? OOD ! txx$**, ,G r-c.d|jdzS)Nz%s*rrrDs rr0zZeroOrMore._as_rhsrr-NrrLr-rrrsA -3r-rc6eZdZdZdgZdfd ZdZdZxZS) OneOrMorezAn expression wrapper like the + quantifier in regexes. You can also pass in an alternate minimum to make this behave like "2 or more", "3 or more", etc. minc>tt| ||||_y)Nr4)rwrrAr)r"memberr5rrGs rrAzOneOrMore.__init__s i'T':r-c|}g} |jdj||||}|n6|j||j|jz }|dk(rn||z }Zt ||j k\rt|||||Syr)rjrSrr(rr7rr ) r"r#r$r%r&rrrPrs rr,zOneOrMore._uncached_matchs<<?--dGUEJD| OOD !XX *F{ v G x=DHH $dC(; ; %r-c.d|jdzS)Nz%s+rrrDs rr0zOneOrMore._as_rhsrr-)rprr{r}s@rrrs  I  <3r-r)rqinspectrrrrr exceptionsrr nodesr r utilsr objectrWrr=r:rtrrrrrrrrrrrLr-rrsML 8" = I+XC"C"L"j"*878%LJ%LP+z+.CxC6EHE$33"3(3* 3x 3"33$ 3 3r-