U md~@sddgZddlZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z m Z m Z ddlmZmZmZddlmZdd ZeZGd d d eZd d ZddZddZddZGdddeZddZddZddZddZ ddZ!dd Z"d!d"Z#d#d$Z$d%d&Z%iZ&e'd'ie&ddl(ZGd(ddeZ)d)d*Z*d+d,Z+Gd-d.d.eZ,d/d0Z-d1d2Z.d3d4Z/d5d6Z0d7d8Z1d9d:Z2Gd;d<dZ4d?d@Z5dS)AEvalEnvironment EvalFactorN) PatsyError)PushbackAdapter no_picklingassert_no_pickling)pretty_untokenizenormalize_token_spacingpython_tokenize)call_and_wrap_exccCsBd}tjD]2}tt|}|}|dks2|tjkr ||jO}q |SNr) __future__all_feature_namesgetattrgetMandatoryReleasesys version_info compiler_flag)flagsZ feature_namefeaturemrrC/home/sam/Atlas/atlas_env/lib/python3.8/site-packages/patsy/eval.py_all_future_flagss   rc@sBeZdZddZddZddZddZdd d Zd d Ze Z d S) VarLookupDictcCsigt||_dSN)list_dicts)selfZdictsrrr__init__.szVarLookupDict.__init__c Cs<|jD](}z||WStk r,YqXqt|dSr)rKeyError)rkeydrrr __getitem__1s  zVarLookupDict.__getitem__cCs||jd|<dSr )r)rr!valuerrr __setitem__9szVarLookupDict.__setitem__cCs,z ||Wntk r"YdSXdSdS)NFTr )rr!rrr __contains__<s  zVarLookupDict.__contains__NcCs(z ||WStk r"|YSXdSrr&)rr!defaultrrrgetDs zVarLookupDict.getcCsd|jj|jfSNz%s(%r)) __class____name__rrrrr__repr__JszVarLookupDict.__repr__)N) r, __module__ __qualname__rr#r%r'r)r.r __getstate__rrrrr-s rcCsddi}ddd}t||g}|ddks.t|ddks>td|ksJtd|ksVtddl}|t|jdd |d<|dd kst|ddkst|ddksttt|t j stt |dS) Nar2br7cr ) rAssertionErrorpytestraisesr r#r) isinstancereprsix string_typesr)Zd1Zd2Zdsr;rrrtest_VarLookupDictPs    rAccsjtjtjtjf}tjdkr*|tjtjf7}tt |D]*}t ||rPt dt |tj r:|j Vq:dS)z~Iterator that yields all the (ast) names in a Python expression. :arg code: A string containing a Python expression. r4zcLambda, list/dict/set comprehension, generator expression in patsy formula not currently supported.N)astLambdaListComp GeneratorExprrDictCompSetCompwalkparser=rNameid)codeZdisallowed_ast_nodesnoderrr ast_namesbs   rPcCsRdddgfddgfdddgfddgfg}|D] \}}tt|t|ks,tq,dS)Nz np.log(x)npxz center(x + 1)centerzdt.date.dt.monthdt)setrPr:)Z test_datarNexpectedrrrtest_ast_namests   rWcCsdddl}dd}|t|d|t|d|t|dtjdkr`|t|d|t|d dS) NrcSs tt|Sr)rrPrNrrrlist_ast_names~sz7test_ast_names_disallowed_nodes..list_ast_nameszlambda x: x + yz[x + 1 for x in range(10)]z(x + 1 for x in range(10))rBz{x: True for x in range(10)}z{x + 1 for x in range(10)})r;r<rrr)r;rYrrrtest_ast_names_disallowed_nodes|s rZc@sveZdZdZdddZeddZddZd ifd d Ze dd d Z ddZ ddZ ddZ ddZddZeZdS)rz}Represents a Python execution environment. Encapsulates a namespace for variable lookup and set of __future__ flags.rcCs"|t@rtt||_||_dSr)_ALL_FUTURE_FLAGSr:r _namespacesr)r namespacesrrrrrs zEvalEnvironment.__init__cCs t|jS)znA dict-like object that can be used to look up variables accessible from the encapsulated environment.)rr\r-rrr namespaceszEvalEnvironment.namespacecCs||j|g|jS)zReturn a new EvalEnvironment with an extra namespace added. This namespace will be used only for variables that are not found in any existing namespace, i.e., it is "outside" them all.)r+r\r)rZouter_namespacerrrwith_outer_namespacesz$EvalEnvironment.with_outer_namespacezcCs*t||d|jd}t|it|g|jS)atEvaluate some Python code in the encapsulated environment. :arg expr: A string containing a Python expression. :arg source_name: A name for this string, for use in tracebacks. :arg inner_namespace: A dict-like object that will be checked first when `expr` attempts to access any variables. :returns: The value of `expr`. evalF)compilerr`rr\)rexprZ source_nameinner_namespacerNrrrr`s  zEvalEnvironment.evalcCst||r|St|tjr$||}ntdt}zFt|dD]}|dkrVtd|j}qB||j |j g|j j t @WS~XdS)aCapture an execution environment from the stack. If `eval_env` is already an :class:`EvalEnvironment`, it is returned unchanged. Otherwise, we walk up the stack by ``eval_env + reference`` steps and capture that function's evaluation environment. For ``eval_env=0`` and ``reference=0``, the default, this captures the stack frame of the function that calls :meth:`capture`. If ``eval_env + reference`` is 1, then we capture that function's caller, etc. This somewhat complicated calling convention is designed to be convenient for functions which want to capture their caller's environment by default, but also allow explicit environments to be specified. See the second example. Example:: x = 1 this_env = EvalEnvironment.capture() assert this_env.namespace["x"] == 1 def child_func(): return EvalEnvironment.capture(1) this_env_from_child = child_func() assert this_env_from_child.namespace["x"] == 1 Example:: # This function can be used like: # my_model(formula_like, data) # -> evaluates formula_like in caller's environment # my_model(formula_like, data, eval_env=1) # -> evaluates formula_like in caller's caller's environment # my_model(formula_like, data, eval_env=my_env) # -> evaluates formula_like in environment 'my_env' def my_model(formula_like, data, eval_env=0): eval_env = EvalEnvironment.capture(eval_env, reference=1) return model_setup_helper(formula_like, data, eval_env) This is how :func:`dmatrix` works. .. versionadded: 0.2.0 The ``reference`` argument. zWParameter 'eval_env' must be either an integer or an instance of patsy.EvalEnvironment.r3Nzcall-stack is not that deep!)r=numbersIntegral TypeErrorinspect currentframerange ValueErrorf_backf_locals f_globalsf_codeco_flagsr[)clseval_env referencedepthframeirrrcaptures-     zEvalEnvironment.capturecs.t|jtfdd|D}t|g|jS)zWCreates a new, flat EvalEnvironment that contains only the variables specified.c3s|]}||fVqdSrr.0nameZvldrr sz)EvalEnvironment.subset..)rr\dictrr)rnamesZnew_nsrrzrsubsets zEvalEnvironment.subsetcCsdd|jDS)NcSsg|] }t|qSr)rM)rxnrrr sz2EvalEnvironment._namespace_ids..)r\r-rrr_namespace_idsszEvalEnvironment._namespace_idscCs&t|to$|j|jko$||kSr)r=rrrrotherrrr__eq__s   zEvalEnvironment.__eq__cCs ||k Srrrrrr__ne__szEvalEnvironment.__ne__cCstt|jt|fSr)hashrrtuplerr-rrr__hash__s zEvalEnvironment.__hash__N)r)rr)r,r/r0__doc__rpropertyr^r_r` classmethodrvr~rrrrrr1rrrrrs    CcCs d}tSNr3_b)_arrrr srcCs d}tSr_crrrrr src Cs<d}ttdtdtjdddtdtddgS)Nr3r)rrr4rrvrrrrrs  rcCsBt\}}}}}}d|jks td|jks.td|jkstd|dj ksRt|d j t@|ksjt|dj t@dkst|dj t@|kstdS)Nr5barry_as_FLUFLdivisionzdef f(): in_f = 'hi from f' global RETURN_INNER, RETURN_OUTER, RETURN_INNER_FROM_OUTER RETURN_INNER = EvalEnvironment.capture(0) RETURN_OUTER = call_capture_0() RETURN_INNER_FROM_OUTER = call_capture_1() f() z execrr3cSs tdSr rrrrrFz4test_EvalEnvironment_capture_flags..cSs tdSrrrrrrrGr)rZcall_capture_0Zcall_capture_1Z RETURN_INNERZin_fz hi from fZRETURN_INNER_FROM_OUTERZ RETURN_OUTERzfrom __future__ import %s z)rrrr rr[r:rarr|r?exec_r^r)Z TEST_FEATURE test_flagsourcerNenvenv2code2rrr"test_EvalEnvironment_capture_flags4sD      rcCstddig}|ddks t|jdddiddks:tddl}|t|jdd }td}|dd ksrt|d d d }|ddkst|dd kstdS) Nr2r3z2 * ar4rcrz2 * br5r9r6)rr`r:r;r< NameErrorrvr_)rr;r2renv3rrr#test_EvalEnvironment_eval_namespace]s rcCsddl}tjdkrtjj}|t@s&ttddigdd}| ddksJt| t |j d| dgj dkspt|d d ij dksttddig|d}| ddkst| t |j d| dgj |kst|d d ij |kstntjj}|t@sttddigdd}| d d kr2d ks8nt| dgj dksPt|d d ij dksjttddig|d}| d d krd ksnt| dgj |k|d d ij |kstdS)Nrrr2 )rza != 0Tza <> 0r7r9za / 2g@)r;rrr rrr[r:rr`r< SyntaxErrorr~rr_r)r;rrrrrrtest_EvalEnvironment_eval_flagsks0  $$rcCstddiddiddig}|dg}|ddks8tddl}|t|jd|t|jd|ddg}|dd kst|t|jddS) Nr2r3r7r4r8r5rzb * cr)rr~r`r:r;r<r)rZsubset_ar;Z subset_bcrrrtest_EvalEnvironment_subsets rcCsXtd}td}||ks tt|t|ks4tdd}|}|}||ksTtdS)NrcSs tdSr rrrrrrrz)test_EvalEnvironment_eq..)rrvr:r)Zenv1rZcapture_local_envrZenv4rrrtest_EvalEnvironment_eqs   rzfrom patsy.builtins import *c@sjeZdZdddZddZddZdd Zd d Zd d ZddZ ddZ ddZ ddZ ddZ eZdS)rNcCst||_||_dS)a/A factor class that executes arbitrary Python code and supports stateful transforms. :arg code: A string containing a Python expression, that will be evaluated to produce this factor's value. This is the standard factor class that is used when parsing formula strings and implements the standard stateful transform processing. See :ref:`stateful-transforms` and :ref:`expert-model-specification`. Two EvalFactor's are considered equal (e.g., for purposes of redundancy detection) if they contain the same token stream. Basically this means that the source code must be identical except for whitespace:: assert EvalFactor("a + b") == EvalFactor("a+b") assert EvalFactor("a + b") != EvalFactor("b + a") N)r rNorigin)rrNrrrrrs zEvalFactor.__init__cCs|jSrrXr-rrrryszEvalFactor.namecCsd|jj|jfSr*)r+r,rNr-rrrr.szEvalFactor.__repr__cCst|to|j|jkSr)r=rrNrrrrrs  zEvalFactor.__eq__cCs ||k SrrrrrrrszEvalFactor.__ne__cCstt|jfSr)rrrNr-rrrrszEvalFactor.__hash__csid<tjfddt|jD}|d<dgfdd}t|j|}|d<td|jrtd t ft j id <dD]t}t ||}t |d kst |d}|\} } | |d kst | | d st |d| t | d} | d |<qg} td} | rt}| D]4}| |g}d |} t|| s4||q4|stt | || |q$| d<t | S)N transformscsg|]}|kr|qSrrrw) env_namespacerrrsz5EvalFactor.memorize_passes_needed..rqrcsZj|}t|drRdd|f}dd7<|}|d|<|dS|SdS)N__patsy_stateful_transform__z_patsy_stobj%s__%s__rr3r .transform)r^r)hasattrr)tokenr$obj_nameobj)rqrustaterrnew_name_makers   z9EvalFactor.memorize_passes_needed..new_name_maker eval_codez5names of this form are reserved for internal use (%s) memorize_coder3r(z.memorize_chunk pass_bins)r__builtins_dictr^rPrNr~replace_bare_funcallshas_bare_variable_referencerrrcapture_obj_method_callslenr: startswithrU differenceadddifference_updateappend)rrrqZ subset_namesrrrZtransform_callsZtransform_callZtransform_call_nameZtransform_call_coderrZunsortedZpass_binZ other_objsr)rrqrurrmemorize_passes_neededsX           z!EvalFactor.memorize_passes_neededcCs(t||dg}td||dj||dS)NrzError evaluating factorrqr)rr r`)rrNmemorize_statedatarcrrr_eval%szEvalFactor._evalcCs,|d|D]}||d|||q dS)Nrrr)rr which_passrrrrrmemorize_chunk-s zEvalFactor.memorize_chunkcCs&|d|D]}|d|q dS)Nrr)memorize_finish)rrrrrrrr3szEvalFactor.memorize_finishcCs||d||S)Nrr)rrrrrrr`7s zEvalFactor.eval)N)r,r/r0rryr.rrrrrrrr`rr1rrrrrs NcCsztd}|jdkst|dks&ttddd}||ks>tt|t|ksRt|jdks`t|jdksntt|dS)Nza+bza + bza +bZasdf)r)rrNr:ryrrr)ee2rrrtest_EvalFactor_basics>s  rc Csddlm}|dd}|dd}|dd}td}i}td}|||}t|t||dksntd D] }|d j|t |ksrtqrd D]}||d jkstq|d d dd ddkst|ddkst|ddddddkst|dt dddgt dggkstdS)Nrstateful_transformcSsdS)NFOO-OBJrrrrrrLrz8test_EvalFactor_memorize_passes_needed..cSsdS)NBAR-OBJrrrrrrMrcSsdS)NQUUX-OBJrrrrrrNrz!foo(x) + bar(foo(y)) + quux(z, w)r4)foobarquuxrq)wrRyzrrrrrr)_patsy_stobj0__foo___patsy_stobj1__bar___patsy_stobj2__foo___patsy_stobj3__quux__rz_patsy_stobj0__foo__.transform(x) + _patsy_stobj1__bar__.transform(_patsy_stobj2__foo__.transform(y)) + _patsy_stobj3__quux__.transform(z, w)rz&_patsy_stobj0__foo__.memorize_chunk(x)zF_patsy_stobj1__bar__.memorize_chunk(_patsy_stobj2__foo__.transform(y))z&_patsy_stobj2__foo__.memorize_chunk(y)z*_patsy_stobj3__quux__.memorize_chunk(z, w)rrrrr) patsy.staterrrrvrprintr:r^localsrU) rrrrrrrqpassesryrrr&test_EvalFactor_memorize_passes_neededJsH         rc@s,eZdZddZddZddZddZd S) _MockTransformcCsd|_d|_d|_dSr )_sum_memorize_chunk_called_memorize_finish_calledr-rrrrvsz_MockTransform.__init__cCs.|jd7_ddl}|j||7_dS)Nr3r)rnumpyrsum)rrrQrrrr{sz_MockTransform.memorize_chunkcCs|jd7_dSr)rr-rrrrsz_MockTransform.memorize_finishcCs ||jSr)r)rrrrr transformsz_MockTransform.transformN)r,r/r0rrrrrrrrrtsrc Csddlm}|t}td}i}td}|||}t|t||dksRt|dj d|kshtdD]}||dj ksltqlddl }| |d| ddg| d d gd |d d j dkst|d dj dkst| |d| ddg| ddgd |d d j dks t|d dj dks8t|d d jdksPt|d djdksht||d|d d jdkst|d djdkst|d dj dkst|d djdkst| |d| ddg| d d gd | |d| ddg| ddgd ||dt|d D]&}|j dksRt|jdks>tq>|||| ddddg| d d ddgd ddddgkstdS)Nrrzfoo(x) + foo(foo(y))r4rqr)rRrrrr3r9r)rRrrrr idr5Z_patsy_stobj1__foo__ic)rrrrrrvrrr:r^rrarrayrrrr? itervaluesallr`) rrrrrqrryrQrrrrtest_EvalFactor_end_to_endsb             rccsvd}tt|}|D]\\}}}i}| o0|tjk|d<|doT|oT|ddk|d<||||fV|dk}qdS)NFbare_refr3r bare_funcall.)rr tokenizeNAMEZhas_morepeek)rNZ prev_was_dotit token_typerrpropsrrrannotated_tokenss rc CsddtdD}|tjddddftjddddftjd dddftjd dddftjd dddftjd dddftjd dddftjddddfgksttttddkstdS)NcSsg|]\}}}}|||fqSrr)rxrrrrrrrrs z)test_annotated_tokens..z a(b) + c.dr2T)rrrFr7)+r8rr"rRr3)rrrOPr:rr)Ztokens_without_originsrrrtest_annotated_tokenss" rcCs0t|D]"\}}}}|dr||krdSqdS)NrTF)r)r}rN_rrrrrrsrcCsHg}t|D]2\}}}}|dr0|dr0||}|||fq t|S)Nrr)rrr)rNreplacertokensrrrrrrrrs rcsTddfdd}|dd|dd|dd|d d |d d |d d dS)NcSsddd||S)Nr7z_internal.foo.process)r2r)r))rrrr replacer1sz-test_replace_bare_funcalls..replacer1cs8t|}td||ftd|f||ks4tdS)Nz%r -> %rz (wanted %r))rrr:)rNrVZreplacedrrrt1s z&test_replace_bare_funcalls..t1zfoobar()za()zb()z foobar.a()zfoo()z_internal.foo.process()za + 1zb() + a() * x[foo(2 ** 3)]z,b() + b() * x[_internal.foo.process(2 ** 3)]r)r rr rtest_replace_bare_funcallss      r c@seZdZddZddZdS)_FuncallCapturercCs*|g|_||fg|_d|_d|_d|_dS)NrF)funcr paren_depthstarteddone)rZstart_token_typeZ start_tokenrrrrs  z_FuncallCapturer.__init__cCs|jr dS|j||f|dkr0|jd7_|dkrF|jd8_|jdksTt|js|dkrjd|_n"|tjks|dkst|j||jr|jdkrd|_dS)N)r{[r3)r}]rrTr) rrrrr:rrrr )rrrrrr add_tokens z_FuncallCapturer.add_tokenN)r,r/r0rrrrrrr sr cCs^g}t|D]B\}}}}|D]}|||q|dr ||kr |t||q dd|DS)NrcSs"g|]}d|jt|jfqS))joinr rr)rxcapturerrrrrsz,capture_obj_method_calls..)rrrr )rrNZ capturersrrrrrrrrrsrcCsVtdddgksttdddgks(ttddddgks>ttd d d gksRtdS) Nrza + foo.baz(bar) + b.c(d))foo.bazz foo.baz(bar)r7)zb.czb.c(d)foo.bar(foo.baz(quux)))zfoo.barr)rz foo.baz(quux)rzfoo[bar.baz(x(z[asdf])) ** 2])zbar.bazzbar.baz(x(z[asdf])))rr:rrrrtest_capture_obj_method_callssr)6__all__rr rgrrDrdr?ZpatsyrZ patsy.utilrrrZ patsy.tokensrr r Z patsy.compatr rr[objectrrArPrWrZrrrrrrrrrrrrZpatsy.builtinsrrrrrrrrrr r rrrrrr s\   #  )!   *4