'ieddlmZddlmZddlZddlmZmZmZm Z m Z ddl m Z m Z mZmZmZmZddlmZmZmZmZmZmZddlmZddlmZGd d eZGd d eZd ZGddeZ GddeZ!dZ"dZ#dZ$dZ%y)) version_info)TestCaseN) BadGrammarLeftRecursionError ParseErrorUndefinedLabelVisitationError)Literal LookaheadRegexSequence TokenMatcher is_callable) rule_grammar rule_syntax RuleVisitorGrammar TokenGrammar LazyReference)Node)Tokenc(eZdZdZdZdZdZdZy)BootstrappingGrammarTestszVTests for the expressions in the grammar that parses the grammar definition syntaxcPd}td}|j|j|t||ddt|jd|ddttd|ddgd}|j|j|t||ddt|jd|ddttd|ddgd}|j|j|t||ddt|jd|ddttd|ddgy) N* quantifierr_children?+)r assertEqualparsermembers)selftextrs P/var/www/br/venv/lib/python3.12/site-packages/parsimonious/tests/test_grammar.pytest_quantifierz)BootstrappingGrammarTests.test_quantifiersB!,/  ))$/ T1aZ''*D!Q7l3>OQUWXZ[9\3^ _ ` ))$/ T1aZ''*D!Q7l3>OQUWXZ[9\3^ _ ` ))$/ T1aZ''*D!Q7l3>OQUWXZ[9\3^ _ `cfd}td}|j|j|t||dt |t|j d|dt |gd}|j|j|t||ddt|j d|ddgy)Nz"anything but quotes#$*&^"spaceless_literalrrzr"\"")rr#r$rlenr%)r&r'r,s r(test_spaceless_literalz0BootstrappingGrammarTests.test_spaceless_literal"s+()<= *006 "D!SY&..q14CIFBH I J *006 "D!Q&..q14A>:@ A Br*cd}td}|jtdj|t||dt |tt d|ddttd|ddttdj d|ddgt|j d |dd ttd |d d gy) Nz~"[a-zA-Z_][a-zA-Z_0-9]*"LIregexr~rr,rr)rr#r$rr.r r%)r&r'r1s r( test_regexz$BootstrappingGrammarTests.test_regex-s,W% g.44T: aTgclD!Q/l#67q",':;CCAFaQSTPVWemmA&b"5l3'r26 68 9 :r*c|jtdjd|jtdjd|jtdjd|jtdjd|jtdjd|jtdjd|jtd jd |jtd jd |jtd jd |jtd jd|jtd jd|jtdjd|jtdjd|jtdjd|jtdjd|jtdjd|jtdjd|jtdjd|jtdjd|jtdjd|jtdjd|jtdjd|jtjdy) zAMake sure the PEG recognition grammar succeeds on various inputs.labelrjeff _THIS_THINGatom some_labelz"some literal"z~"some regex"i quantifiedz~"some regex"i*zthing+z"hi"?termthiszthat+sequencezthis that? otheroredzthis / that+ / "other"lookahead_termz&this+ expressionzthis? that other*z&this / that+ / "other"zthis / that? / "other"+rulez this = that zthis = the? that other* z the=~"hi*" z this = the? that other* that = "thing" the=~"hi*" other = "ahoy hoy" N) assertTruerr$r&s r(test_successesz(BootstrappingGrammarTests.test_successes8s  W-33C89  W-33F;<  W-33MBC  V,22<@A  V,223CDE  V,223CDE  \2889JKL  \288BC  \288AB  V,226:;  V,227;<  Z0667IJK  V,223KLM  %56<BC  **, r*N)__name__ __module__ __qualname____doc__r)r/r6rGr*r(rrs ` B :(r*rc"eZdZdZdZdZdZy)RuleVisitorTestszTests for ``RuleVisitor`` As I write these, Grammar is not yet fully implemented. Normally, there'd be no reason to use ``RuleVisitor`` directly. c tjd}tj|\}}d}|j |j|t ||ddy)aTest a simple round trip. Parse a simple grammar, turn the parse tree into a map of expressions, and use that to parse another piece of text. Not everything was implemented yet, but it was a big milestone and a proof of concept. znumber = ~"[0-9]+" 98rr4N)rr$rvisitr#r)r&treerules default_ruler's r(test_round_tripz RuleVisitorTests.test_round_tripjsW!!"<=)m11$7| ++D14 dAq3QRr*ctjd}|jtt j |y)z:Make sure we throw the right exception on undefined rules.z boy = howdy N)rr$ assertRaisesrrrQ)r&rRs r(test_undefined_rulez$RuleVisitorTests.test_undefined_rulezs,!!/2 .+-*=*=tDr*ctjd}tj|\}}d}|j |j|t ||ddt t d|ddgy)Nzboy = "howdy"? howdyrr-r)rr$rrQr#rr )r&rRrSrTrZs r( test_optionalzRuleVisitorTests.test_optionalsx!!"45)m11$7| ++E2DuaQR+/0@%A+N^P5Q Rr*N)rHrIrJrKrUrXr[rLr*r(rNrNcs S E Rr*rNcNd}||dj|r|t|zSdS)zfThis is an example of a grammar rule implemented as a function, and is provided as a test fixture.functionN startswithr.r'postokens r( function_rulercs0 E#CDz44U;3U EEr*ceZdZdZdZedZdeiZdZdZ dZ dZ d Z d Z d Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"d Z#d!Z$d"Z%y#)$ GrammarTestsz@Integration-test ``Grammar``: feed it a PEG and see if it works.cNd}||dj|r|t|zSdS)zhThis is an example of a grammar rule implemented as a method, and is provided as a test fixture.methodNr^)r&r'rarbs r( method_rulezGrammarTests.method_rules0#':#8#8#?sSZITIr*cNd}||dj|r|t|zSdS)zlThis is an example of a grammar rule implemented as a descriptor, and is provided as a test fixture. descriptorNr^r`s r(descriptor_rulezGrammarTests.descriptor_rules0#':#8#8#?sSZITIr*rkctd}|jd}|j|t|ddddtt ddddgy)a,Test the ``Grammar`` base class's ability to compile an expression tree from rules. That the correct ``Expression`` tree is built is already tested in ``RuleGrammarTests``. This tests only that the ``Grammar`` base class's ``_expressions_from_rules`` works. zgreeting = "hi" / "howdy"higreetingrr4rN)rr$r#rr )r&greeting_grammarrRs r(test_expressions_from_rulesz(GrammarTests.test_expressions_from_ruless]##>?%%d+ t$4Z$@$1GDM4A6X8 9 :r*c:td}t|j}|j|dd|j dt dk\rdndz|v|j d|v|j d |v|jt |d y ) zVAssert that a ``Grammar`` can convert into a string-formatted series of rules. bold_text = bold_open text bold_close text = ~"[A-Z 0-9]*"i bold_open = "((" bold_close = "))" rz%bold_text = bold_open text bold_closetext = ~'[A-Z 0-9]*'i%suzbold_open = '(('zbold_close = '))'N)rstr splitlinesr#rErr.)r&grammarliness r( test_unicodezGrammarTests.test_unicodes G '') q#JK 1LDConstructing a Grammar with bad rules should raise ParseError.zjust a bunch of junkN)rWrrrFs r(test_bad_grammarzGrammarTests.test_bad_grammars *g/EFr*c td}|jttt |j dddt dk\rdndzgy) z?Test tolerance of comments and blank lines in and around rules.a4# This is a grammar. # It sure is. bold_text = stars text stars # nice text = ~"[A-Z 0-9]*"i #dude stars = "**" # Pretty good #Oh yeah.#zbold_text = stars text starsz stars = '**'rsrtrvrwN)rr#listsortedryrzrr&r{s r( test_commentszGrammarTests.test_commentss[ ( ) fS\%<%<%>?@ / *\T5Ic357  8 9r*c^td}|j|jdduy)zaMake sure we tolerate all sorts of crazy line breaks and comments in the middle of rules.z bold_text = bold_open # commenty comment text # more comment bold_close text = ~"[A-Z 0-9]*"i bold_open = "((" bold_close = "))" z ((booyah))NrrEr$rs r(test_multi_linezGrammarTests.test_multi_lines/  l34?@r*ctd}|jt|jd|j |jdduy)z8Make sure "not" predicates get parsed and work properly.znot_arp = !"arp" ~"[a-z]+"arpargleN)rrWrr$rErs r(test_notzGrammarTests.test_nots=;< *gmmU;  g.d:;r*c.td}|jt|jdd}|j |jdt |d|ddt t td|ddt td|ddg y) Nzstarts_with_a = &"a" ~"[a-z]+"burpr starts_with_arruaz[a-z]+r) rrWrr$r#rr r r rs r(test_lookaheadzGrammarTests.test_lookaheads?@ *gmmV<  u-tGO4LaQRTU&*9WS\+BAq!&L&*5+;Q1&EaG0H Ir*ctd}|jt|jdd}|j t |j|dy)Nz!sequence = "chitty" (" " "bang")+zchitty bangbangzchitty bang banga8 )rrWrr$r#ryrs r( test_parenszGrammarTests.test_parenssLBC *gmm5FG  W]]1-. & 'r*c<td}|jdy)zCSmoke-test a circumstance where lazy references don't get resolved.z expression = "(" terms ")" terms = term+ term = number number = ~r"[0-9]+" z(34)Nrr$rs r(test_resolve_refs_orderz$GrammarTests.test_resolve_refs_orders  fr*c<td}|jdy)zISmoke-test another circumstance where lazy references don't get resolved.a> block = "{" _ item* "}" _ # An item is an element of a block. item = number / word / block / paren # Parens are for delimiting subexpressions. paren = "(" _ item* ")" _ # Words are barewords, unquoted things, other than literals, that can live # in lists. We may renege on some of these chars later, especially ".". We # may add Unicode. word = spaceless_word _ spaceless_word = ~r"[-a-z`~!@#$%^&*_+=|\\;<>,.?][-a-z0-9`~!@#$%^&*_+=|\\;<>,.?]*"i number = ~r"[0-9]+" _ # There are decimals and strings and other stuff back on the "parsing" branch, once you get this working. _ = meaninglessness* meaninglessness = whitespace whitespace = ~r"\s+" z{log (add 3 to 5)}Nrrs r(test_resolve_refs_completenessz+GrammarTests.test_resolve_refs_completeness s *  *+r*ctdy)zSmoke-test a grammar that was causing infinite loops while building. This was going awry because the "int" rule was never getting marked as resolved, so it would just keep trying to resolve it over and over. z digits = digit+ int = digits digit = ~"[0-9]" number = int main = number N)rrFs r(test_infinite_loopzGrammarTests.test_infinite_loop9s  r*cZtjt5tddddtjt5tddddtjt5tddddy#1swYdxYw#1swYCxYw#1swYyxYw)NzA foo = bar bar = foo zA foo = foo bar = foo z[ foo = bar bar = baz baz = foo )pytestraisesr rrFs r( test_circular_toplevel_referencez-GrammarTests.test_circular_toplevel_referenceHs ]]? +     ]]? +     ]]? +             s# B  B4 B! BB!B*c^td}|j|jdduy)z$Right-recursive refs should resolve.zN digits = digit digits? digit = ~r"[0-9]" 12Nrrs r(test_right_recursivez!GrammarTests.test_right_recursiveZs-  d+478r*c<|jdtdy)zQUselessly circular references should be detected by the grammar compiler.z6We have yet to make the grammar compiler detect these.z< foo = bar bar = foo N)skipTestrrFs r(test_badly_circularz GrammarTests.test_badly_circularbs NO r*c8tdjdy)zwMake sure a parenthesized expression is allowed to have leading whitespace when nested directly inside another.zfoo = ( ("c") )cNrrFs r(#test_parens_with_leading_whitespacez0GrammarTests.test_parens_with_leading_whitespaceks %&,,S1r*c8tdjdy)Nz foo = 'a' '"'za"rrFs r(test_single_quoted_literalsz(GrammarTests.test_single_quoted_literalsps#$**40r*ctdd}d}|j|j|t|d|ddt|d|dd t|d |d d t|d |d dg y)z1Run 2-arg custom-coded rules through their paces.z\ bracketed_digit = start digit end start = '[' end = ']'c6||jr|dzSdSNr)isdigitr'ras r(z7GrammarTests.test_simple_custom_rules..ys%!%c!2!2!4S1W:>r*digit[6]bracketed_digitrrustartrrr4endrNrr#r$rrs r(test_simple_custom_rulesz%GrammarTests.test_simple_custom_rulesss? @  q) *+Q1WW%q!Q/WW%q!Q/WU^Q1-@/ 0 1r*ctdd}d}|j|j|t|d|ddt|d|dd t|d |d d t|d |d dg y)zRun 5-arg custom rules through their paces. Incidentally tests returning an actual Node from the custom rule. zy bracketed_digit = start digit end start = '[' end = ']' real_digit = '6'c0|dj||||S)N real_digit) match_core)r'racacheerrorr{s r(rz8GrammarTests.test_complex_custom_rules..s L)44T3uMr*rrrrrurrrr4rrNrrs r(test_complex_custom_rulesz&GrammarTests.test_complex_custom_ruless  N O  q) *+Q1WW%q!Q/W\*Aq!4WU^Q1-@/ 0 1r*c tdttdtddjd}d}|j |j |t |d|dd t |d|dd t |d|d d g y ) zMake sure LazyReferences manually shoved into custom rules are resolved. Incidentally test passing full-on Expressions as custom rules and having a custom rule as the default one. z. four = '4' five = '5'fourfive forty_five)name)r45rr4rrN)rr rdefaultr#r$rrs r(test_lazy_custom_rulesz#GrammarTests.test_lazy_custom_ruless f 5 -f 5%134 5.s S1Wr*)one_charr4rrN)rrr#r$rrs r(test_unconnected_custom_rulesz*GrammarTests.test_unconnected_custom_rulessK#<=EEjQ  q) $aA . 0r*c|jtt|jt|j|jt|jdy)Nrk)rErrcrhrSrFs r(test_callability_of_routinesz)GrammarTests.test_callability_of_routinessE  M23  D$4$456  DJJ/@$ABCr*ctdt|j|jd}|j d}|j Dcgc]}|j j}}|j|gdycc}w)zxConfirms that functions, methods and method descriptors can all be used to supply custom grammar rules. z> default = function method descriptor rk)r]rgrjfunctionmethoddescriptorN) rrcrhrSr$r exprrr#)r&r{resultnode rule_namess r(test_callability_custom_rulesz*GrammarTests.test_callability_custom_rulessu###zz"34  9:17AdiinnA A %IJBs A>c ztd}|j|jdt|ddddy)zMake sure we get an actual rule set as our default rule, even when the first rule has forward references and is thus a LazyReference at some point during grammar compilation. zK styled_text = text text = "hi" rmr'rr4Nrrs r(test_lazy_default_rulez#GrammarTests.test_lazy_default_rules=  t,d76?D!Q.OPr*ctd}d}|jt||gd}|jt||gy)z:Make sure that a Grammar is immutable after being created.z! foo = 'bar' cd|d<y)NrfoorL)r{s r( mod_grammarz8GrammarTests.test_immutable_grammar..mod_grammars GENr*c<td}|j|y)Nz* baz = 'biff' )rupdate)r{ new_grammars r(rz8GrammarTests.test_immutable_grammar..mod_grammars!#K NN; 'r*N)rrW TypeErrorAttributeError)r&r{rs r(test_immutable_grammarz#GrammarTests.test_immutable_grammarsE    )[7)< ( .+yAr*cJ|jttdy)Nz foo = "a")rEreprrrFs r( test_reprzGrammarTests.test_reprs W\234r*ctdjdtdD}|jt |j tdDcgc]}d|z c}ycc}w)N c3&K|] }d|z ywzr%s = "something"NrL.0is r( z?GrammarTests.test_rule_ordering_is_preserved..#P$7!$;#Pdr%s)rjoinranger#rkeysr&r{rs r(test_rule_ordering_is_preservedz,GrammarTests.test_rule_ordering_is_preservedsT$))#PU3Z#PPQ   %c +1UQY + - +s A/ ctdjdtdDj}|j t |j tdDcgc]}d|z c}ycc}w)Nrc3&K|] }d|z ywrrLrs r(rzQGrammarTests.test_rule_ordering_is_preserved_on_shallow_copies..rrrr)rrr_copyr#rrrs r(1test_rule_ordering_is_preserved_on_shallow_copiesz>GrammarTests.test_rule_ordering_is_preserved_on_shallow_copiess]$))#PU3Z#PPQWWY   %c +1UQY + - +s) A= c ttd}dtdDcgc]}d|z c}fdtddDcgc]}d|z c}fdd gfd td dDcgc]}d|z c}fd d dgfdddgfdgdfg}|D]"\}}|D]}||j|rJ$ddgfdtdDcgc]}d|z c}fdttdttddzDcgc]}d|z c}fd ttd ttddzDcgc]}d|z c}fd dgfdd gfddgfg}|D]B\}}|D]8}t j t 5||j|ddd:Dycc}wcc}wcc}wcc}wcc}wcc}w#1swYexYw)Nz left_missing = "a"{,5} right_missing = "a"{5,} exact = "a"{5} range = "a"{2,5} optional = "a"? plus = "a"+ star = "a"* left_missingrr right_missingr-rexactaaaaarr4optionalrwplusaastar)rwrr aaaaaa b)rrr$rrrr)r&r{r should_parserDexamplesexampleshould_not_parses r(test_repetitionszGrammarTests.test_repetitionss  uQx8!cAg8 9 a <1sQw< = wi a 41sQw4 5 "c # c4[ ! _ % + 4ND(# 4t}**7333 4 4 gY ' a91sQw9 : U1XeArl9K(KL1sQwL M U1XeArl9K(KL1sQwL M $ bTN cUO / 1ND(# 1]]:.1DM''011 1 1+9<4:LL11s. F F F 3 F/ F$ + F) .F..F7 cjd}t|t|k(sJ|jtttt|jtdtd|jtdtd|jtdtdy)NzP x = y / z / "" y = "y" x z = "z" x zexpr = ~"[a-z]{1,3}"zexpr = ~"[a-z]{2,3}"zexpr = ~"[a-z]{1,4}"z expr = &"a"z expr = !"a")rr#rassertNotEqual)r& grammar_defs r( test_equalzGrammarTests.test_equal s {#w{';;;; -w{/CD G$:;WE[=\] G$:;WE[=\] GM2GM4JKr*N)&rHrIrJrKrh staticmethodrkrSrpr}rrrrrrrrrrrrrrrrrrrrrrrrrrrrrLr*r(reresJJ JJ  0E :(" QG9* A< I'",2 $92 1 1102( 0D K QB"5- - #1J Lr*rec(eZdZdZdZdZdZdZy)TokenGrammarTestsz9Tests for the TokenGrammar class and associated machineryctdtdg}td}|j|j|t |d|ddt |d|ddt t d|ddgy ) zToken literals should work.token1token2zM foo = token1 "token2" token1 = "token1" rrr4rrN)rrr#r$rr)r&rr{s r(test_parse_successz$TokenGrammarTests.test_parse_success1s} 8_eHo .  q) AqWX&1a0\(+Q1547 8 9r*ctd}tjt5}|j t dt dgddddt jvsJy#1swY#xYw)z8Parse failures should work normally with token literals.z1 foo = "token1" "token2" tokenBOOrNzRule 'foo' didn't match at)rrrrr$rryvalue)r&r{es r(test_parse_failurez$TokenGrammarTests.test_parse_failure=sj ]]: & @! MM5,eHo> ? @+s177|;;; @ @s &A--A6ctd}|jt|jt|j d|jy)Nu💣u)rrE isinstance__repr__ryr#)r&ts r(test_token_reprz!TokenGrammarTests.test_token_reprFs; &M  1::<56 )1::<8r*ctd}td}td}|djgJ|dj|gJ|dj||gJtjt 5|dj||gdddtjt 5|dj|gddd|dj|gJtjt 5|dj||gdddtjt 5|dj|gdddy#1swYxYw#1swYxYw#1swYYxYw#1swYyxYw)Nrr z7 foo = "a"* bar = "a"+ rbar)rrr$rrr)r&rr r{s r( test_token_star_plus_expressionsz2TokenGrammarTests.test_token_star_plus_expressionsKsx #J #J  u~##B'333u~##QC(444u~##QF+777 ]]: & ) EN !Q ( ) ]]: & & EN ! % &u~##QC(444 ]]: & ) EN !Q ( ) ]]: & & EN ! % & & ) ) & & ) ) & &s0E8E)E5>FE&)E25E>F N)rHrIrJrKrr"r'r*rLr*r(rr.sC 9<9 &r*rc&td}t|dtsJ|djdk(sJt j t 5|jddddtd}|jdsJy#1swY(xYw)Nz; escaped_bell = r"\b" r = "irrelevant" escaped_bellz\bz irrelevantz" escaped_bell = r"\b" )rr$r literalrrrr$)gg2s r(#test_precedence_of_string_modifiersr0bs  A a' 11 1 ^  $ $ -- - z "     B 88E??   s BBcDtd}d}|jdJy)Nz file = header body terminator header = b"\xFF" length b"~" length = ~rb"\d+" body = ~b"[^\xFF]*" terminator = b"\xFF" s22~aaaaaaaaaaaaaaaaaaaaaar)r.lengths r(test_binary_grammarr4ts. AF 775 6 BB Br*ctjt5}tddddjj t usJtjt5}tdddd|jj t usJtdtdy#1swYxYw#1swYJxYw)Nz: foo = b"foo" bar = "bar" z; foo = ~b"foo" bar = "bar" z/ foo = b"foo" bar = b"bar" z- foo = "foo" bar = "bar" )rrr rr original_classr)r!s r()test_inconsistent_string_types_in_grammarr7s  ' 1   77 ! !Z // /  ' 1   77 ! !Z // /      '    s B.% B:.B7:Ccd}t|}tjt5}|dj dddddt j vsJy#1swY#xYw)Nz expression = operator_expression / non_operator_expression non_operator_expression = number_expression operator_expression = expression "+" non_operator_expression number_expression = ~"[0-9]+" operator_expressionz1+2zDParsimonious is a packrat parser, so it can't handle left recursion.)rrrrr$ryr )language_grammarr{r!s r(test_left_associativer;sj&'G ) *4a%&,,U34 QUXYZY`Y`Ua aa a44s AA')&sysrunittestrrparsimonious.exceptionsrrrrr parsimonious.expressionsr r r r rrparsimonious.grammarrrrrrrparsimonious.nodesrparsimonious.utilsrrrNrcrerr0r4r7r;rLr*r(rCs ooccmm#$QQh%Rx%RPFYL8YLx 1&1&h$ C 4br*