U Kv f~@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_nameZfeaturemrr./tmp/pip-unpacked-wheel-68fdvdus/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) Nar1br6cr ) rAssertionErrorpytestraisesrr"r( isinstancereprsix string_typesr)d1Zd2Zdsr: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. r3zcLambda, list/dict/set comprehension, generator expression in patsy formula not currently supported.N)astLambdaZListCompZ GeneratorExprrZDictCompZSetCompwalkparser<rNameid)codeZdisallowed_ast_nodesnoderrr ast_namesbs   rLcCsRdddgfddgfdddgfddgfg}|D] \}}tt|t|ks,tq,dS)Nz np.log(x)npxz center(x + 1)centerzdt.date.dt.monthdt)setrLr9)Z test_datarJexpectedrrrtest_ast_namests   rScCsdddl}dd}|t|d|t|d|t|dtjdkr`|t|d|t|d dS) NrcSs tt|Sr)rrLrJrrrlist_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:rUrrrtest_ast_names_disallowed_nodes|s rVc@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_FLAGSr9r _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.)rrXr,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*rXr)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\rrX)rexprZ source_nameinner_namespacerJrrrr\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.r2Nzcall-stack is not that deep!)r<numbersIntegral TypeErrorinspect currentframerange ValueErrorf_backf_locals f_globalsf_codeco_flagsrW)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..)rrXdictrr)rnamesZnew_nsrrvrsubsets zEvalEnvironment.subsetcCsdd|jDS)NcSsg|] }t|qSr)rI)rtnrrr sz2EvalEnvironment._namespace_ids..)rXr,rrr_namespace_idsszEvalEnvironment._namespace_idscCs&t|to$|j|jko$||kSr)r<rrr}rotherrrr__eq__s   zEvalEnvironment.__eq__cCs ||k Srrr~rrr__ne__szEvalEnvironment.__ne__cCstt|jt|fSr)hashrrtupler}r,rrr__hash__s zEvalEnvironment.__hash__N)r)rr)r+r.r/__doc__rpropertyrZr[r\ classmethodrrrzr}rrrrr0rrrrrs    CcCs d}tSNr2_b)_arrrr srcCs d}tSr_crrrrr src Cs<d}ttdtdtjdddtdtddgS)Nr2r)rnr3rrrrrrrrs  rcCsBt\}}}}}}d|jks td|jks.td|jkstd|dj ksRt|d j t@|ksjt|dj t@dkst|dj t@|kstdS)Nr4barry_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 execrr2cSs 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 rrWr9r]rrxr>exec_rZr)Z TEST_FEATURE test_flagsourcerJenvenv2code2rrr"test_EvalEnvironment_capture_flags4sD      rcCstddig}|ddks t|jdddiddks:tddl}|t|jdd }td}|dd ksrt|d d d }|ddkst|dd kstdS) Nr1r2z2 * ar3r_rz2 * br4r8r5)rr\r9r:r; NameErrorrrr[)rr:r1renv3rrr#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)Nrrr1 )rza != 0Tza <> 0r6r8za / 2g@)r:rrr rrrWr9rr\r; SyntaxErrorrzrr[r)r:rrrrrrtest_EvalEnvironment_eval_flagsks0  $$rcCstddiddiddig}|dg}|ddks8tddl}|t|jd|t|jd|ddg}|dd kst|t|jddS) Nr1r2r6r3r7r4rzb * cr)rrzr\r9r:r;r)rZsubset_ar:Z subset_bcrrrtest_EvalEnvironment_subsets rcCsXtd}td}||ks tt|t|ks4tdd}|}|}||ksTtdS)NrcSs tdSr rrrrrrrz)test_EvalEnvironment_eq..)rrrr9r)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 rJorigin)rrJrrrrrs zEvalFactor.__init__cCs|jSrrTr,rrrruszEvalFactor.namecCsd|jj|jfSr))r*r+rJr,rrrr-szEvalFactor.__repr__cCst|to|j|jkSr)r<rrJr~rrrrs  zEvalFactor.__eq__cCs ||k Srrr~rrrrszEvalFactor.__ne__cCstt|jfSr)rrrJr,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|qSrrrs) env_namespacerrr|sz5EvalFactor.memorize_passes_needed..rmrcsZj|}t|drRdd|f}dd7<|}|d|<|dS|SdS)N__patsy_stateful_transform__z_patsy_stobj%s__%s__rr2r .transform)rZr(hasattrr)tokenr#obj_nameobj)rmrqstaterrnew_name_makers   z9EvalFactor.memorize_passes_needed..new_name_maker eval_codez5names of this form are reserved for internal use (%s) memorize_coder2r(z.memorize_chunk pass_bins)r[_builtins_dictrZrLrJrzreplace_bare_funcallshas_bare_variable_referencerrrcapture_obj_method_callslenr9 startswithrQ differenceadddifference_updateappend)rrrmZ subset_namesrrrZtransform_callsZtransform_callZtransform_call_nameZtransform_call_coderrZunsortedZpass_binZ other_objsr)rrmrqrrmemorize_passes_neededsX           z!EvalFactor.memorize_passes_neededcCs(t||dg}td||dj||dS)NrzError evaluating factorrmr)rr r\)rrJmemorize_statedatar_rrr_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.r/rrur-rrrrrrrr\rr0rrrrrs NcCsztd}|jdkst|dks&ttddd}||ks>tt|t|ksRt|jdks`t|jdksntt|dS)Nza+bza + bza +bZasdf)r)rrJr9rurrr)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)r3)foobarquuxrm)wrNyzrrrrrr)_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.staterrrrrrprintr9rZlocalsrQ) rrrrrrrmpassesrurrr&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)Nr2r)rnumpyrsum)rrrMrrrr{sz_MockTransform.memorize_chunkcCs|jd7_dSr)rr,rrrrsz_MockTransform.memorize_finishcCs ||jSr)r)rrrrr transformsz_MockTransform.transformN)r+r.r/rrrrrrrrrtsrc 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))r3rmr)rNrrrr2r8r)rNrrrr idr4Z_patsy_stobj1__foo__ic)rrrrrrrrrr9rZrrarrayrrrr> itervaluesallr\) rrrrrmrrurMrrrrtest_EvalFactor_end_to_endsb             rccsvd}tt|}|D]\\}}}i}| o0|tjk|d<|doT|oT|ddk|d<||||fV|dk}qdS)NFbare_refr2r bare_funcall.)rr tokenizeNAMEZhas_morepeek)rJZ prev_was_dotit token_typerrpropsrrrannotated_tokenss rc CsddtdD}|tjddddftjddddftjd dddftjd dddftjd dddftjd dddftjd dddftjddddfgksttttddkstdS)NcSsg|]\}}}}|||fqSrr)rtrrrrrrrr|s z)test_annotated_tokens..z a(b) + c.dr1T)rrrFr6)+r7rr!rNr2)rrrOPr9rr)Ztokens_without_originsrrrtest_annotated_tokenss" rcCs0t|D]"\}}}}|dr||krdSqdS)NrTF)r)ryrJ_rrrrrrsrcCsHg}t|D]2\}}}}|dr0|dr0||}|||fq t|S)Nrr)rrr)rJreplacertokensrrrrrrrrs rcsTddfdd}|dd|dd|dd|d d |d d |d d dS)NcSsddd||S)Nr6z_internal.foo.process)r1r)r()rrrr replacer1sz-test_replace_bare_funcalls..replacer1cs8t|}td||ftd|f||ks4tdS)Nz%r -> %rz (wanted %r))rrr9)rJrRZreplacedrrrt1s 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)rrrrtest_replace_bare_funcallss      rc@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{[r2)r}]rrTr) r rrrr9r rrr)rrrrrr add_tokens z_FuncallCapturer.add_tokenN)r+r.r/rrrrrrrsrcCs^g}t|D]B\}}}}|D]}|||q|dr ||kr |t||q dd|DS)NrcSs"g|]}d|jt|jfqS))joinrrr)rtcapturerrrrr|sz,capture_obj_method_calls..)rrrr)rrJZ capturersrrrrrrrrrsrcCsVtdddgksttdddgks(ttddddgks>ttd d d gksRtdS) Nrza + foo.baz(bar) + b.c(d))foo.bazz foo.baz(bar)r6)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])))rr9rrrrtest_capture_obj_method_callssr)6__all__rr rcrrDr`r>ZpatsyrZ patsy.utilrrrZ patsy.tokensrr r Z patsy.compatr rrWobjectrrArLrSrVrrrrrrrrrrrrZpatsy.builtinsrrrrrrrrrrrrrrrrr s\   #  )!   *4