iKj)dZddlZddlmZddlZddlmZmZmZm Z ddl m Z ddl m Z ddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZdgZdee deedee de!e fdZ"GddejFZ$dZ%eedddejLdddejjde dzde'e ejFe fdzdejFe dejFe f d Z(y)!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. N) signature) NonTerminalRuleSymbolTerminal)Lark) TerminalDef) strategies)InvalidArgument)ConjectureData)calc_label_from_name) check_type)IncompatibleWithAlphabet) cacheabledefines_strategy from_lark terminalsrules ignore_namesreturnc |Dchc]}|jc}t|z}|D]:}||jDchc]}t|ts|j!c}z}<|Scc}wcc}w)aCGet 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 Z/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/hypothesis/extra/lark.pyget_terminal_namesr *sf' 'QVV '#l*; ;EM $..LQJq(4K!&&LLM L (LsA(A-A-c eZdZdZdededzdeeejefdejeddf fd Z d e defd Z d ede fd Z d e d edeeddfdZd e deeddfdZdZxZS) LarkStrategyzcLow-level strategy implementation wrapping a Lark grammar. See ``from_lark`` for details. grammarstartNexplicitalphabetrc j tt|tjjsJ||j j n|g}t|jjj}d|vr!|jj|d\}}} nBd|vr |jj|\}}} n|jj\}}} i_ |D]/} | jj| jj<1t} i_|D]} t!| jj| j<t#j| j$j'} | fdt(dt"j*t(dt,fd}t/j0| d| j3|} |j5|j| j<t;fd | D_t?||| }tAt||z x}rtCd |d tA||D chc]} | jc} z t|z x}r0tCd dtE|dkDzdtA|d|ddjjG|i}|D]m}| jId|jJDs&|jM|jjgjOt;|jJohj|tQ||jSDcic]/\}}|Dcgc]}tUfd|Ds|c}x}r||1c}}}x}k7rlhj|tQ||jSDcic]/\}}|Dcgc]}tUfd|Ds|c}x}r||1c}}}x}k7rlt|jIrtCdt;|d|t/jV|Dcgc]}|vsj|c}_|jSDcic]*\}}|t/jVtA|tD,c}}_,i_-y#t6$r| j9| jYwxYwcc} wcc}wcc}}}wcc}wcc}}}wcc}wcc}}w)Nterminals_to_keepr$stringpatternrcd|j|}|J|jt|k(SN)matchendlen)r*r+r.s rlexes_entirelyz-LarkStrategy.__init__..lexes_entirelycs1 f-(((yy{c&k11T) fullmatchr&c3<K|]}j|ywr-)names_to_symbols).0nselfs r z(LarkStrategy.__init__..ws$T!T%:%:1%=$TszLThe 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("")}}`c34K|]}|jywr-r)r6rs rr9z(LarkStrategy.__init__..s$DQVV$Dsc3:K|]}|jvywr-r>)r6r? allowed_ruless rr9z(LarkStrategy.__init__..s1Ua!&&M2I1UszNo start rule z is allowed by alphabet=)key).super__init__rlarkroptionsr$rr#compile parametersr5originrrterminal_strategiesrrer+ to_regexpstrPatternboolst from_regexfiltervalidateraddtupleignored_symbolsr sortedr r0update isdisjointr setdefaultappenddictitemsall sampled_fromnonterminal_strategies_LarkStrategy__rule_labels)r8r#r$r%r&starts compile_argsrrrr? disallowedrr+r1r: all_terminalsunknown_explicitmissing_declared nonterminalsrkvxcleanrA __class__s` @rrDzLarkStrategy.__init__@s '499>>222*/-&&eW !!8!89DD , .-4__-D-DVR-P *Iul  $-4__-D-DV-L *Iul.5__-D-D-F *Iul35 :  s1AAsymbol draw_statect|tr:|j|j}|j |j |yt|t sJ|j|j|j |j |j|j}|D]'}|j||||j||) |jy#|jwxYwr-) rrrJrr[rqr start_spanrxr`rr gen_ignore stop_span)r8rnryrzstrategyres rrrzLarkStrategy.draw_symbols fh '// .inners32T9: r2r))rrs` rcheck_explicitrs Lr2T)force_reusable_valueszutf-8)codec)r$r%r&r#r$r%r&c "ttjj|d|i}nRtt|d|j Dcic]&\}}||j t d|d|(}}}t||||Scc}}w)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]=)rrErr\r]maprr")r#r$r%r&rirjs rrrs@tyy~~w 24:.!( 1 quu^iuBqe$<=> >   ( ;;  s+B ))rrKinspectrrE lark.grammarrrrr lark.larkr lark.lexerr hypothesisr rPhypothesis.errorsr #hypothesis.internal.conjecture.datar $hypothesis.internal.conjecture.utilsr hypothesis.internal.validationr%hypothesis.strategies._internal.regexr%hypothesis.strategies._internal.utilsrr__all__rrMrr rr"r charactersr\rr)r2rrs0   <<"'->E5JM - K  )-d CG9 X  Z2$$Zz -9='4r}}7'C '< YY^^'< :'<3))#../$6 '< $ '< s '<. '