=SrSSKJr SSKrSSKJr SSKJrJrJ r J r J r J r SSKJ r Jr SrS r"S S \5r"S S \5r"SS\5r"SS\5rSSjrSrg)a Compiler for a regular grammar. Example usage:: # Create and compile grammar. p = compile('add \s+ (?P[^\s]+) \s+ (?P[^\s]+)') # Match input string. m = p.match('add 23 432') # Get variables. m.variables().get('var1') # Returns "23" m.variables().get('var2') # Returns "432" Partial matches are possible:: # Create and compile grammar. p = compile(''' # Operators with two arguments. ((?P[^\s]+) \s+ (?P[^\s]+) \s+ (?P[^\s]+)) | # Operators with only one arguments. ((?P[^\s]+) \s+ (?P[^\s]+)) ''') # Match partial input string. m = p.match_prefix('add 23') # Get variables. (Notice that both operator1 and operator2 contain the # value "add".) This is because our input is incomplete, and we don't know # yet in which rule of the regex we we'll end up. It could also be that # `operator1` and `operator2` have a different autocompleter and we want to # call all possible autocompleters that would result in valid input.) m.variables().get('var1') # Returns "23" m.variables().get('operator1') # Returns "add" m.variables().get('operator2') # Returns "add" )unicode_literalsN)range)AnySequenceRegexVariableRepeat Lookahead) parse_regextokenize_regex)compileinvalid_trailingcZ\rSrSrSrS SjrSrSr\S5r \S5r S r S r S r g) _CompiledGrammar;a1 Compiles a grammar. This will take the parse tree of a regular expression and compile the grammar. :param root_node: :class~`.regex_parser.Node` instance. :param escape_funcs: `dict` mapping variable names to escape callables. :param unescape_funcs: `dict` mapping variable names to unescape callables. Nc z^^UTlU=(d 0TlU=(d 0Tl0TlS/mUU4SjnSTR X5-Tl[ TRX55Tl[Rn[R"TR U5Tl TRVs/sHn[R"Xe5PM snTl TRVs/sH6n[R"SURS5<S[<S3U5PM8 snTlgs snfs snf)Nrcd>STS-nURTRU'TS==S- ss'U$)Nzn%srr)varname_group_names_to_nodes)nodenamecounterselfs Dlib/third_party/prompt_toolkit/contrib/regular_languages/compiler.pycreate_group_func4_CompiledGrammar.__init__..create_group_funcMs771:%D/3||D & &t , AJ!OJK^%s$(?:$z)(?P.*?)$) root_node escape_funcsunescape_funcsr _transform _re_patternlist_transform_prefix_re_prefix_patternsreDOTALLr_re _re_prefixrstrip_INVALID_TRAILING_INPUT_re_prefix_with_trailing_input)rr"r#r$rflagstrs` @r__init___CompiledGrammar.__init__Ds"(.B,2&("# "DOOI$QQ#'(>(>y(\#]  ::d..69=9Q9QR9QA2::a/9QR--//- JJ ?VWY^ _-//+ S //s 7 D3-=D8cZURRU5nU(aU"U5$U$)zG Escape `value` to fit in the place of this variable into the grammar. )r#getrrvaluefs rescape_CompiledGrammar.escapeds+    ! !' *qx'%'rcZURRU5nU(aU"U5$U$)z Unescape `value`. )r$r6r7s runescape_CompiledGrammar.unescapeks+    # #G ,qx'%'rc$^^UU4SjmT"U5$)z Turn a :class:`Node` object into a regular expression. :param root_node: The :class:`Node` instance for which we generate the grammar. :param create_group_func: A callable which takes a `Node` and returns the next free name for this node. c">[U[5(a(SSRU4SjUR55-$[U[5(a%SRU4SjUR55$[U[ 5(a UR $[U[5(a-UR(aSOSnUT"UR5-S-$[U[5(a!S T"U5<S T"UR5<S3$[U[5(a[S T"UR5URURcSO[UR5UR(aS4-$S 4-$[!S U<35e)N(?:%s)|c34># UH nT"U5v M g7fN.0c transforms r A_CompiledGrammar._transform..transform..~s*OA9Q<<c34># UH nT"U5v M g7frDrErFs rrJrKsC]y||]rLz(?!z(=)(?P<>z(?:%s){%i,%s}%s?zGot ) isinstancerjoinchildrenrrregexr negative childnoder r min_repeat max_repeatstrgreedy TypeError)rbeforerrIs rrI._CompiledGrammar._transform..transform{sA$$$#((*O*O"OOOD(++wwCT]]CCCD%((zz!D),,#'==%d $.. 99C??D(++'8'> $..@YZZD&))(dnn-t??2RDOO8L;;R,-0,  D 344rrE)clsr"rrIs `@rr%_CompiledGrammar._transformrs 5>##rc#N^^^# UUU4SjmT"U5H nSU-v M g7f)a Yield all the regular expressions matching a prefix of the grammar defined by the `Node` instance. This can yield multiple expressions, because in the case of on OR operation in the grammar, we can have another outcome depending on which clause would appear first. E.g. "(A|B)C" is not the same as "(B|A)C" because the regex engine is lazy and takes the first match. However, because we the current input is actually a prefix of the grammar which meight not yet contain the data for "C", we need to know both intermediate states, in order to call the appropriate autocompletion for both cases. :param root_node: The :class:`Node` instance for which we generate the grammar. :param create_group_func: A callable which takes a `Node` and returns the next free name for this node. c 3># [U[5(a*URHnT "U5H nSU-v M M g[U[5(a[ [ UR55HgnURSUVs/sHnTR UT5PM nnT "URU5HnSSRU5U--v M Mi g[U[5(aSUR-v g[U[5(a>UR(a"STR URT5-v g[S5e[U[5(a-T "UR5HnST"U5<SU<S3v M g[U[5(aTR URT5nT "UR5HPnUR (aS UR S - -nOS nS U<SU<UR"(aSOS <S U<S3v MR g[%SU-5es snf7f)Nz(?:%s)?rArMz(?!%s)z%Positive lookahead not yet supported.rPrQrOz{,%i}r*r rRz)?zGot %r)rSrrUrrlenr%rTrrVr rWrX Exceptionr r rZr\r]) rrHriaprefix repeat_signr`rrIs rrI5_CompiledGrammar._transform_prefix..transforms$$$A&q\'!m+*'D(++s4==12AGK}}UWVWGXYGX!+<=GXAY&t}}Q'78&"''!*q.9993 D%(($**,,D),,=="S^^DNNDU%VVV$$KLLD(++#4>>2A*;D*A1EE3D&))8IJ"4>>2A&-11D&E &) ##{{3  3 400OZsBI  I&F#I rNrE)r`r"rrgrIs` ` @rr("_CompiledGrammar._transform_prefixs'&4 1l9%A1* &s %cURRU5nU(a.[XRU4/URUR5$g)z Match the string with the grammar. Returns a :class:`Match` instance or `None` when the input doesn't match the grammar. :param string: The input string. N)r,matchMatchrr$)rstringms rro_CompiledGrammar.matchsC HHNN6 " 88Q-$2L2LdNaNab b rc.URUR4HnnUVs/sHo3URU54PM nnUVVs/sHup5U(dMX54PM nnnU/:wdMM[XURUR 5s $ gs snfs snnf)a" Do a partial match of the string with the grammar. The returned :class:`Match` instance can contain multiple representations of the match. This will never return `None`. If it doesn't match at all, the "trailing input" part will capture all of the input. :param string: The input string. N)r-r0rorprr$)rrqpatternsrgmatchesrrs r match_prefix_CompiledGrammar.match_prefixs$*M*MNH5=>X1776?+XG>*17'$!Qvv'G7"}Vd.H.H$J]J]^^ O>7sB  BB) rr,r&r-r)r0r#r"r$NN)__name__ __module__ __qualname____firstlineno____doc__r3r:r= classmethodr%r(rorw__static_attributes__rErrrr;sO/@(('$'$RIIV c_rrcB\rSrSrSrSrSrSrSrSr Sr S r S r g ) rpiz :param string: The input string. :param re_matches: List of (compiled_re_pattern, re_match) tuples. :param group_names_to_nodes: Dictionary mapping all the re group names to the matching Node instances. c4XlX lX0lX@lgrD)rq _re_matchesr_unescape_funcs)rrq re_matchesgroup_names_to_nodesr$s rr3Match.__init__ s %%9"-rc0^U4Sjn[U"55$)z) Return a list of (varname, reg) tuples. c3># TRHWupURR5H4up#U[:wdMURUnTR UnXT4v M6 MY g7frD)r groupindexitemsr/regsr)rgre_match group_name group_indexregrrs r get_tuples(Match._nodes_to_regs..get_tuplessb#// /0||/A/A/C+J!%<<&mmK8#99*E#k) 0D 0s 9A,,A,)r')rrs` r_nodes_to_regsMatch._nodes_to_regss *JL!!rc^SnU4SjnTR5VVs/sHup4U"U5(aMX2"U5U4PM snn$s snnf)z6 Returns list of list of (Node, string_value) tuples. c0USS:H=(a USS:H$)NrrrE)slices ris_none'Match._nodes_to_values..is_none%s8r>4eAh"n 4rc.>TRUSUS$Nrr)rq)rrs rr6#Match._nodes_to_values..get(s;;uQxa1 1r)r)rrr6rrs` r_nodes_to_valuesMatch._nodes_to_values!sM 5 2DHCVCVCXoCX`ghm`n,#e*e,CXooos AAcZURRU5nU(aU"U5$U$rD)rr6)rrr8 unwrappers r _unescapeMatch._unescape-s*((,,W5 #,y7%7rc [UR5VVVs/sHupo1URX5U4PM snnn5$s snnnf)z& Returns :class:`Variables` instance. ) Variablesrr)rkvsls r variablesMatch.variables1s>H]H]H_`H_HA"dnnQ2B7H_`aa`s A cd/nURHRup#URR5H/upEU[:XdMUR UR U5 M1 MT U(aE[ SU55[ SU55/nURUSUSn[SXv5$g)z Get the `MatchVariable` instance, representing trailing input, if there is any. "Trailing input" is input at the end that does not match the grammar anymore, but when this is removed from the end of the input, the input would be a valid string. c3*# UH oSv M g7f)rNrErGrhs rrJ'Match.trailing_input..Hs.v!1vc3*# UH oSv M g7f)rNrErs rrJrHs3I&QaD&rrrzN) rrrr/appendrmaxrq MatchVariable)rslicesrgrrrrr8s rtrailing_inputMatch.trailing_input7s  ++KA+,<<+=+=+?' !88MM(-- "<=,@, .v..3I&3I0IJEKKaq2E !3UB B rc## UR5H]upUS[UR5:XdM#URXRUSUS5n[ XUSUS45v M_ g7f)zn Yields `MatchVariable` instances for all the nodes having their end position at the end of the input string. rrN)rrerqrr)rrrr8s r end_nodesMatch.end_nodesLsl !//1LG1vT[[))w CFCF0KL#GSVSV4DEE 2s 0A5?A5)rrrrqN) rzr{r|r}r~r3rrrrrrrrErrrprps. . " p8b C* Frrpc<\rSrSrSrSrS SjrSrSrSr S r g) riXcXlgrD_tuples)rtupless rr3Variables.__init__Ys rc~URR<SSRSUR55<S3$)N(, c38# UHupo1<SU<3v M g7f)=NrE)rGrr_s rrJ%Variables.__repr__.._s.\|GA!!Q/?|srO) __class__rzrTrrs r__repr__Variables.__repr__]s0 NN # #TYY.\t||.\%\^ ^rNc@URU5nU(aUS$U$)Nr)getall)rkeydefaultrs rr6 Variables.getas! C  uQx-g-rcfURVVVs/sHup#oBU:XdM UPM snnn$s snnnfrDr)rrrrrs rrVariables.getalles&!%:gaAc:::s ,,c$URU5$rD)r6)rrs r __getitem__Variables.__getitem__hsxx}rc#T# URHupn[XU5v M g7f)z" Yield `MatchVariable` instances. N)rrrrr8rs r__iter__Variables.__iter__ks'&*\\ !GE6 6&2s&(rrD) rzr{r|r}r3rr6rrrrrErrrrXs!^.;7rrc$\rSrSrSrSrSrSrg)risa Represents a match of a variable in the grammar. :param varname: (string) Name of the variable. :param value: (string) Value of this variable. :param slice: (start, stop) tuple, indicating the position of this variable in the input string. cxXlX lX0lURSUlURSUlgr)rr8rstartstoprs rr3MatchVariable.__init__|s/   ZZ] JJqM rcnURR<SUR<SUR<S3$)NrrrO)rrzrr8rs rrMatchVariable.__repr__s!#~~66 djjQQr)rrrr8rN)rzr{r|r}r~r3rrrErrrrss"Rrrc<[[[U55UUS9$)zR Compile grammar (given as regex string), returning a `CompiledGrammar` instance. )r#r$)_compile_from_parse_treer r ) expressionr#r$s rrrs$ $N:./!% ''rc [U/UQ70UD6$)zP Compile grammar (given as parse tree), returning a `CompiledGrammar` instance. )r)r"rikws rrrs I 0 0R 00rry)r~ __future__rr* six.movesr regex_parserrrrr r r r r __all__r/objectrrprrrrrErrrst'P( KK5 -I_vI_XNFFNFb776RFR*'1r