i&SrSSKJr SSKrSSKJrJrJrJr SSK J r SSK J r SSK Jr SSKJr SS KJr SS KJr SS KJr SS KJr SS KJrJr S/rS\\ S\\S\\S\ \4Sjr!"SS\RD5r#Sr$\\"SS9SS\RJ"SS9S.S\RRS\S-S\&\\RD\4S-S\RD\S\RD\4 S jj55r'g)!a This extra can be used to generate strings matching any context-free grammar, using the `Lark parser library `_. It currently only supports Lark's native EBNF syntax, but we plan to extend this to support other common syntaxes such as ANTLR and :rfc:`5234` ABNF. Lark already `supports loading grammars `_ from `nearley.js `_, so you may not have to write your own at all. ) signatureN) NonTerminalRuleSymbolTerminal)Lark) TerminalDef) strategies)InvalidArgument)ConjectureData)calc_label_from_name) check_type)IncompatibleWithAlphabet) cacheabledefines_strategy from_lark terminalsrules ignore_namesreturnc UVs1sHo3RiM sn[U5-nUHCnXERVs1sH&n[U[5(dMURiM( sn-nME U$s snfs snf)a/Get names of all terminals in the grammar. The arguments are the results of calling ``Lark.grammar.compile()``, so you would think that the ``terminals`` and ``ignore_names`` would have it all... but they omit terminals created with ``@declare``, which appear only in the expansion(s) of nonterminals. )nameset expansion isinstancer)rrrtnamesrules T/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/hypothesis/extra/lark.pyget_terminal_namesr )se' 'YVVY '#l*; ;E ..L.QJq(4K&!&&.LL L (LsA4A9A9c ^\rSrSrSrS\S\S-S\\\R\4S\R\SS4 U4S jjr S \ S\4S jr S \S\ 4S jrS \ S\S\\SS4SjrS \ S\\SS4SjrSrSrU=r$) LarkStrategy9z[Low-level strategy implementation wrapping a Lark grammar. See ``from_lark`` for details. grammarstartNexplicitalphabetrc  >^^[TT]5 [U[RR5(deUcUR R OU/n[URR5RnSU;a URRUS5upgnOBSU;aURRU5upgnOURR5upgn0Tl UH0n U RTRU RR'M2 [5n 0TlUHn [!U R5TRU R'["R$"U R&R)5SUS9n U R+5 U TRU R'M [1U4SjU55Tl[5XgU5n [7[U5U - 5=n(a[9SUS35e[7XV s1sHoRiM sn - [U5- 5=n(a2[9S S [;U5S :-S [7U5<S US<S35eTRR=U5 0nUHtnU R?SUR@55(dM,URCURR/5RE[1UR@55 Mv 1TRkUkm[GU5URI5VVVs0sHAunnUVs/sH!n[KU4SjU55(dMUPM# sn=n(dM>UU_MC snnn=n:wa1TRkUkm[GU5URI5VVVs0sHAunnUVs/sH!n[KU4SjU55(dMUPM# sn=n(dM>UU_MC snnn=n:waM[U5R?T5(a[1U5SU<35e["RL"UV s/sHoT;dM TRU PM sn 5TlURI5VVs0sH)unnU["RL"[7U[:S95_M+ snnTl'0Tl(g![,a U R/U R5 GMf=fs sn fs snfs snnnfs snfs snnnfs sn fs snnf)Nterminals_to_keepr%T) fullmatchr'c3B># UHnTRUv M g7fN)names_to_symbols).0nselfs r (LarkStrategy.__init__..hs$T|!T%:%:1%=|szLThe following arguments were passed as explicit_strategies, but there is no z% terminal production in this grammar.zUndefined terminals z}. Generation does not currently support use of %declare unless you pass `explicit`, a dict of names-to-strategies, such as `{rz: st.just("")}}`c38# UHoRv M g7fr-r)r/rs rr2r3s$D^VV^sc3@># UHoRT;v M g7fr-r8)r/r9 allowed_ruless rr2r3s1USTa&&M2ISTszNo start rule z is allowed by alphabet=)key))super__init__rlarkroptionsr%rr$compile parametersr.originrrterminal_strategiesrst from_regexpattern to_regexpvalidateraddtupleignored_symbolsr sortedr lenupdate isdisjointr setdefaultappenddictitemsall sampled_fromnonterminal_strategies_LarkStrategy__rule_labels)r1r$r%r&r' compile_argsrrrr9 disallowedrr4 all_terminalsunknown_explicitmissing_declared nonterminalsrkvxcleanr; __class__s` @rr>LarkStrategy.__init__?s '499>>222249M7??00w !!8!89DD , .-4__-D-DUB-O *Il  $-4__-D-DU-K *Il.5__-D-D-F *Il35A3488D ! !!((-- 0U FH A,4QVV,T" T" T. T)8T)>T. T. + T58T5*0T:+%TTT" )T. datac/nURUR5nURXU5 SRU5$)N)drawr% draw_symboljoin)r1restater%s rdo_drawLarkStrategy.do_draws7 $**% e,wwu~rcURU$![a+ URRU[SU355s$f=f)NzLARK:)rXKeyErrorrQr )r1rs r rule_labelLarkStrategy.rule_labelsQ %%d+ + %%00*U4&>:  s2AAsymbol draw_statec[U[5(a:URURnUR UR U55 g[U[ 5(deURURUR55 UR URUR5nUH&nURXU5 URX5 M( UR5 gr-) rrrDrrRrhr start_spanrqrWri gen_ignore stop_span)r1rersrtstrategyres rriLarkStrategy.draw_symbols fh ' '// r rlintrqrlistrirwr__static_attributes__ __classcell__)rcs@rr"r"9s \0\0Tz\0sB--c223 \0 ##C( \0  \0|Ns ssI   $5~54955 rnr"c^U4SjnU$)Nc0>[[UST-5 U$)Nzvalue drawn from )rr)valuers rinnercheck_explicit..inners32T9: rnr*)rrs` rcheck_explicitrs LrnT)force_reusable_valueszutf-8)codec)r%r&r'r$r%r&r'c &[[RRUS5 Uc0nOU[[US5 UR 5VVs0sH'upEXER [ SU<SU<355_M) nnn[XX#5$s snnf)aA strategy for strings accepted by the given context-free grammar. ``grammar`` must be a ``Lark`` object, which wraps an EBNF specification. The Lark EBNF grammar reference can be found `here `_. ``from_lark`` will automatically generate strings matching the nonterminal ``start`` symbol in the grammar, which was supplied as an argument to the Lark class. To generate strings matching a different symbol, including terminals, you can override this by passing the ``start`` argument to ``from_lark``. Note that Lark may remove unreachable productions when the grammar is compiled, so you should probably pass the same value for ``start`` to both. Currently ``from_lark`` does not support grammars that need custom lexing. Any lexers will be ignored, and any undefined terminals from the use of ``%declare`` will result in generation errors. To define strategies for such terminals, pass a dictionary mapping their name to a corresponding strategy as the ``explicit`` argument. The :pypi:`hypothesmith` project includes a strategy for Python source, based on a grammar and careful post-processing. r$r&z explicit[z]=)rr?rrSrTmaprr")r$r%r&r'r_r`s rrrs@tyy~~w 24:.!( ( uu^iuBqe$<=> >(    ;;  s.B )(rinspectrr? lark.grammarrrrr lark.larkr lark.lexerr hypothesisr rEhypothesis.errorsr #hypothesis.internal.conjecture.datar $hypothesis.internal.conjecture.utilsr hypothesis.internal.validationr%hypothesis.strategies._internal.regexr%hypothesis.strategies._internal.utilsrr__all__rrrr rr"r charactersrSrr*rnrrs+  <<"'->E5JM - K  )-d CG9 X  J2$$JZ -9=')}}7'C '< YY^^'< :'<3))#../$6 '< $ '< s '<. '