B Úsüd¶ã.@sždZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlmZddlmZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddl m!Z!ddl m"Z"ddl#m$Z$ddl%m&Z&ddl'm(Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/ddl.m0Z0ddl1m2Z2er¦ddl%m3Z3e j4dkrÌej5Z6ej7Z8ej7Z9ej7Z:nej;Z6ejZ:e2dƒZ?e j@jA›de$›ZBdd rd!pd"ZCd#eBeCZDGd$d%„d%ejEjFejEjGƒZHeeIe jJejKdd&œd'd(„ZLdejKe jJeeMd)œd*d+„ZNee+ee jJejKfd,œd-d.„ZOd/d0„feeeePgdfeejKd1œd2d3„ZQdxejReIeePee+dd4œd5d6„ZSeTePd7œd8d9„ZUee+eeVd:œd;d<„ZWeTePd7œd=d>„ZXeTeMd7œd?d@„ZYeePeMePdAœdBdC„ZZeePeeMeePeeTePdDœdEdF„Z[eVePePddGœdHdI„Z\eMdJœdKdL„Z]ej^dMej_dNej`dOejadPiZbejcdQejddRejedSejfdTejgdUejhdVejidWejjdXejkdYejldZejmd[ejnd\ejod]ejpd^ejqd_ejrd`ejsdaejtdbejudcejvddejwdeejxdfejydgiZzej{eej{dhœdidj„Z|ej}dkdleIeeVePfdmœdndo„ƒZ~Gdpdq„dqejƒZ€eeMdrœdsdt„Zeeduœdvdw„Z‚dS)yz5Rewrite assertion AST to produce nice error messages.éN)ÚPath)ÚPurePath)ÚCallable)ÚDict)ÚIO)ÚIterable)ÚIterator)ÚList)ÚOptional)ÚSequence)ÚSet)ÚTuple)Ú TYPE_CHECKING)ÚUnion)ÚDEFAULT_REPR_MAX_SIZE)Úsaferepr)Úversion)Úutil)Úformat_explanation)ÚConfig)ÚSession)Ú absolutepath)Ú fnmatch_ex)ÚStashKey)ÚAssertionState)éérz-pytest-z.pyTÚcÚoÚ.c@sPeZdZdZeddœdd„Zeeddœdd„Ze j j j Z d*eeeeeefeejee j jd œd d „Z e j jeejd œd d„Zejddœdd„Zededœdd„Zeededœdd„Zededœdd„Zeddœdd„Zeddœdd „Zeeefed!œd"d#„Zejd$krLejd%kr0d&d'l m!Z!n d&d'l"m!Z!ee!dœd(d)„Z#dS)+ÚAssertionRewritingHookz1PEP302/PEP451 import hook which rewrites asserts.N)ÚconfigÚreturncCsh||_y| d¡|_Wntk r4ddg|_YnXd|_i|_tƒ|_d|_dh|_ i|_ d|_ dS)NZ python_filesz test_*.pyz *_test.pyFZconftest) r!ÚgetiniÚfnpatsÚ ValueErrorÚsessionÚ_rewritten_namesÚsetÚ _must_rewriteÚ _writing_pycÚ_basenames_to_check_rewriteÚ_marked_for_rewrite_cacheÚ_session_paths_checked)Úselfr!©r/úH/home/dcms/DCMS/lib/python3.7/site-packages/_pytest/assertion/rewrite.pyÚ__init__FszAssertionRewritingHook.__init__)r&r"cCs||_d|_dS)NF)r&r-)r.r&r/r/r0Ú set_sessionVsz"AssertionRewritingHook.set_session)ÚnameÚpathÚtargetr"cCs¢|jr dS|jjt}| ||¡r&dS| d|¡| ||¡}|dksp|jdkspt|j t j j ƒrpt j |j¡stdS|j}| |||¡sŒdSt jj||||jdS)Nzfind_module called for: %s)ÚloaderÚsubmodule_search_locations)r*r!ÚstashÚassertstate_keyÚ_early_rewrite_bailoutÚtraceÚ _find_specÚoriginÚ isinstancer6Ú importlibÚ machineryÚSourceFileLoaderÚosr4ÚexistsÚ_should_rewriterÚspec_from_file_locationr7)r.r3r4r5ÚstateÚspecÚfnr/r/r0Ú find_spec]s(    z AssertionRewritingHook.find_spec)rGr"cCsdS)Nr/)r.rGr/r/r0Ú create_module…sz$AssertionRewritingHook.create_module)Úmoduler"c Cs|jdk st‚|jjdk st‚t|jjƒ}|jjt}||j|j<t j }t |ƒ}|rvt |ƒ}|svd}|  d|›¡|jdd…t}||}t|||j ƒ} | dkrî|  d|›¡t||jƒ\} } |rþd|_zt|| | |ƒWdd|_Xn|  d|›¡t| |jƒdS)NFzread only directory: éýÿÿÿz rewriting Tzfound cached rewritten pyc for )Ú__spec__ÚAssertionErrorr=rr!r8r9r'Ú__name__ÚsysÚdont_write_bytecodeÚ get_cache_dirÚ try_makedirsr;r3ÚPYC_TAILÚ _read_pycÚ _rewrite_testr*Ú _write_pycÚexecÚ__dict__) r.rKrHrFÚwriteÚ cache_dirÚokZ cache_nameÚpycÚcoÚ source_statr/r/r0Ú exec_moduleŠs2    z"AssertionRewritingHook.exec_moduler)r3rFr"cCsÐ|jdk rT|jsTd|_x<|jjD]0}t|ƒ tj¡}|j tj   |d¡d¡q W| d¡}|d|jkrpdSt |Ž  d¡}x,|j D]"}tj  |¡ršdSt||ƒr†dSq†W| ||¡r¼dS| d|›¡dS) a'A fast way to get out of rewriting modules. Profiling has shown that the call to PathFinder.find_spec (inside of the find_spec from this class) is a major slowdown, so, this method tries to filter what we're sure won't be rewritten before getting to it. NTéÿÿÿÿrrFz.pyz early skip of rewriting module: )r&r-Z _initialpathsÚstrÚsplitrBÚsepr+Úaddr4ÚsplitextrÚ with_suffixr$ÚdirnamerÚ_is_marked_for_rewriter;)r.r3rFZ initial_pathÚpartsr4Úpatr/r/r0r:´s$      z-AssertionRewritingHook._early_rewrite_bailout)r3rHrFr"cCs”tj |¡dkr$| d|›¡dS|jdk rR|j t|ƒ¡rR| d|›¡dSt|ƒ}x,|jD]"}t ||ƒrb| d|›¡dSqbW|  ||¡S)Nz conftest.pyzrewriting conftest file: Tz.matched test file (was specified on cmdline): zmatched test file ) rBr4Úbasenamer;r&Z isinitpathrrr$rri)r.r3rHrFZfn_pathrkr/r/r0rDÛs   z&AssertionRewritingHook._should_rewritec Cszy |j|Stk rtxJ|jD]@}||ks<| |d¡r"| d|›d|›d¡d|j|<dSq"Wd|j|<dSXdS)Nrzmatched marked file z (from ú)TF)r,ÚKeyErrorr)Ú startswithr;)r.r3rFZmarkedr/r/r0riðs    z-AssertionRewritingHook._is_marked_for_rewrite)Únamesr"cGstt|ƒ tj¡ |j¡}x@|D]8}tj|}t |jp8d¡st |j t |ƒƒs|  |¡qW|j  |¡|j ¡dS)zžMark import names as needing to be rewritten. The named module or package as well as any nested modules will be rewritten on import. ÚN)r(Ú intersectionrPÚmodulesÚ differencer'ÚAssertionRewriterÚis_rewrite_disabledÚ__doc__r>Ú __loader__ÚtypeÚ_warn_already_importedr)Úupdater,Úclear)r.rpZalready_importedr3Úmodr/r/r0Ú mark_rewriteýs    z#AssertionRewritingHook.mark_rewrite)r3r"cCs(ddlm}|jj|d|ƒdddS)Nr)ÚPytestAssertRewriteWarningz2Module already imported so cannot be rewritten: %sé)Ú stacklevel)Ú_pytest.warning_typesrr!Zissue_config_time_warning)r.r3rr/r/r0rzs  z-AssertionRewritingHook._warn_already_imported)Úpathnamer"c Cst|dƒ }| ¡SQRXdS)zOptional PEP302 get_data API.ÚrbN)ÚopenÚread)r.rƒÚfr/r/r0Úget_datas zAssertionRewritingHook.get_data)ré )ré r)ÚTraversableResourcescCs:tjdkrddlm}n ddlm}|tj|j|dƒS)N)ré r)Ú FileReader)r4)rPÚ version_infoZimportlib.readersrZimportlib.resources.readersÚtypesÚSimpleNamespacer')r.r3rr/r/r0Úget_resource_reader$s   z*AssertionRewritingHook.get_resource_reader)NN)$rOÚ __module__Ú __qualname__rwrr1r rr2r?r@Ú PathFinderrIr<rbr rÚbytesrÚ ModuleTypeÚ ModuleSpecrJr`Úboolr:rDrir~rzrˆrPrŽZimportlib.resources.abcr‹Ú importlib.abcr‘r/r/r/r0r Cs* $*'     r )Úfpr_r^r"cCs\| tjj¡d}| |¡t|jƒd@}|jd@}| t d||¡¡| t   |¡¡dS)Nslÿÿzfór¸)rµr]r;r"c CsÄyt|dƒ}Wntk r"dSX|y(t |¡}t|jƒ}|j}| d¡}Wn6tk rŠ}z|d|›d|›ƒdSd}~XYnXt|ƒdkr¨|d|ƒdS|dd…t j j krÌ|d|ƒdS|dd …d krì|d |ƒdS|d d …} t  | d ¡|d@kr|d|ƒdS|d d…} t  | d ¡|d@krP|d|ƒdSyt  |¡} Wn8tk r–}z|d|›d|›ƒdSd}~XYnXt| tjƒs¶|d|ƒdS| SQRXdS)zsPossibly read a pytest pyc containing rewritten code. Return rewritten code if successful or None if not. r„Néz _read_pyc(z ): OSError z&_read_pyc(%s): invalid pyc (too short)éz-_read_pyc(%s): invalid pyc (bad magic number)rsz._read_pyc(%s): invalid pyc (unsupported flags)rŠÚlittlelÿÿz_read_pyc(%s): out of datez+_read_pyc(%s): invalid pyc (incorrect size)z): marshal.load error z _read_pyc(%s): not a code object)r…r©rBr¯rœrržr†Úlenr?rr›Ú from_bytesr¡ÚloadÚ Exceptionr>rÚCodeType) rµr]r;ršÚ stat_resultr¤r¥Údatar¬Z mtime_dataZ size_datar^r/r/r0rUesN           rU)r}rµÚ module_pathr!r"cCst|||ƒ |¡dS)z%Rewrite the assert statements in mod.N)ruÚrun)r}rµrÄr!r/r/r0r³–sr³)Úobjr"cCsttjƒ}t||d dd¡S)a§Get a safe repr of an object for assertion error messages. The assertion formatting (util.format_explanation()) requires newlines to be escaped since they are a special character for it. Normally assertion.util.format_explanation() does this but for a custom repr it is possible to contain one of the special escape sequences, especially '\n{' and '\n}' are likely to be present in JSON reprs. )ÚmaxsizeÚ z\n)Ú_get_maxsize_for_safereprrÚ_configrr«)rÆrÇr/r/r0Ú _saferepr s rË)r!r"cCs6|dk r| d¡nd}|dkr"dS|dkr2tdStS)zJGet `maxsize` configuration for saferepr based on the given config object.NÚverboseréér‰)Z getoptionr)r!Ú verbosityr/r/r0rÉ®s rÉcCsFddg}t|tƒs$t|ƒ}| d¡x|D]\}}| ||¡}q*W|S)zñFormat the custom assertion message given. For strings this simply replaces newlines with '\n~' so that util.format_explanation() will preserve them instead of escaping newlines. For other objects saferepr() is used first. )rÈz ~)ú%z%%)z\nz ~)r>rbrÚappendr«)rÆZreplacesÚr1Úr2r/r/r0Ú_format_assertmsg¸s   rÔcCs2t|ƒr dSy t|dƒ Stk r,dSXdS)NFrOT)ÚcallableÚhasattrrÀ)rÆr/r/r0Ú_should_repr_global_nameÎs  r×)Ú explanationsÚis_orr"cCs&d|r dp d |¡d}| dd¡S)Nú(z or z and rmrÐz%%)Újoinr«)rØrÙÚ explanationr/r/r0Ú_format_boolopØsrÝ)ÚopsÚresultsÚexplsÚeach_objr"c Cs†xLttt|ƒƒ||ƒD]4\}}}y | }Wntk rBd}YnX|rPqWtjdk r‚t ||||||d¡}|dk r‚|S|S)NTrÎ)ÚzipÚranger½rÀrZ _reprcompare) rÞrßràráÚiÚresÚexplÚdoneZcustomr/r/r0Ú_call_reprcompareÝs    rè)ÚlinenoÚorigrær"cCstjdk rt |||¡dS)N)rÚ_assertion_pass)rérêrær/r/r0Ú_call_assertion_passñs rì)r"cCstjr dSdS)zŠCheck if any plugins implement the pytest_assertion_pass hook in order not to generate explanation unnecessarily (might be expensive).TF)rrër/r/r/r0Ú_check_if_assertion_pass_implösríznot %sz~%sz-%sz+%sú|ú^ú&z<>ú+ú-Ú*ú/z//z%%z==z!=úz>=z**Úiszis notÚinznot inú@)Únoder"ccs,|Vx t |¡D]}t|ƒEdHqWdS)zARecursively yield node and all its children in depth-first order.N)r±Úiter_child_nodesÚ traverse_node)rúÚchildr/r/r0rüsrürÎ)rÇ)Úsrcr"c s¸i‰d‰g‰d‰tƒ‰ddœ‡‡‡‡‡fdd„ }t t |¡j¡}xn|D]d\}}\}}}}|tjkrv|dkrv|‰qJˆdk rJ|tjkrš|dkršˆd7‰n|tjkr´|d kr´ˆd8‰ˆsÖˆ ||d…¡ˆ |¡qJˆdkrv|tjkrv|d krv|ˆkr._write_and_resetÚassertz([{rÎz)]}ú,ra) r(ÚtokenizeÚioÚBytesIOÚreadlineÚNAMEÚOPrÑrer½ÚNEWLINEÚ ENDMARKER) rþrÚtokensÚtprµréÚoffsetÚ_ÚlineZoffset_in_trimmedr/)rrrrrr0Ú_get_assertion_exprs s@       rcseZdZdZeeeeeddœ‡fdd„ Ze j ddœdd„Z e ee d œd d „ƒZed œd d„Ze je jdœdd„Ze je jdœdd„Zee je jdœdd„Zee jdœdd„Ze jedœdd„Zdd œdd„Ze je jdœdd „Ze jee jefd!œd"d#„Ze jee jd$œd%d&„Z e!ee!efdœd'd(„Z"e jee jefdœd)d*„Z#e j$ee jefd+œd,d-„Z%e j&ee jefd.œd/d0„Z'e j(ee jefd1œd2d3„Z)e j*ee jefd4œd5d6„Z+e j,ee j,efd7œd8d9„Z-e jee jefd:œd;d<„Z.e j/ee jefd=œd>d?„Z0‡Z1S)@ruaŒ Assertion rewriting implementation. The main entrypoint is to call .run() with an ast.Module instance, this will then find all the assert statements and rewrite them to provide intermediate values and a detailed assertion error. See http://pybites.blogspot.be/2011/07/behind-scenes-of-pytests-new-assertion.html for an overview of how this works. The entry point here is .run() which will iterate over all the statements in an ast.Module and for each ast.Assert statement it finds call .visit() with it. Then .visit_Assert() takes over and is responsible for creating new ast statements to replace the original assert statement: it rewrites the test of an assertion to provide intermediate values and replace it with an if statement which raises an assertion error with a detailed explanation in case the expression is false and calls pytest_assertion_pass hook if expression is true. For this .visit_Assert() uses the visitor pattern to visit all the AST nodes of the ast.Assert.test field, each visit call returning an AST node and the corresponding explanation string. During this state is kept in several instance attributes: :statements: All the AST statements which will replace the assert statement. :variables: This is populated by .variable() with each variable used by the statements so that they can all be set to None at the end of the statements. :variable_counter: Counter to create new unique variables needed by statements. Variables are created using .variable() and have the form of "@py_assert0". :expl_stmts: The AST statements which will be executed to get data from the assertion. This is the code which will construct the detailed assertion message that is used in the AssertionError or for the pytest_assertion_pass hook. :explanation_specifiers: A dict filled by .explanation_param() with %-formatting placeholders and their corresponding expressions to use in the building of an assertion message. This is used by .pop_format_context() to build a message. :stack: A stack of the explanation_specifiers dicts maintained by .push_format_context() and .pop_format_context() which allows to build another %-formatted string while already building one. :variables_overwrite: A dict filled with references to variables that change value within an assert. This happens when a variable is reassigned with the walrus operator This state, except the variables_overwrite, is reset on every new assert statement visited and used by the other visitors. N)rÄr!rµr"csBtƒ ¡||_||_|dk r,| d¡|_nd|_||_i|_dS)NÚenable_assertion_pass_hookF)Úsuperr1rÄr!r#rrµÚvariables_overwrite)r.rÄr!rµ)Ú __class__r/r0r1s  zAssertionRewriter.__init__)r}r"cs,|js dSt|ddƒ}|dk}|dk r4| |¡r4dSd}d}x†|jD]|}|r”t|tjƒr”t|jtƒr”tj dkrx|jj}n|jj }| |¡rŽdSd}n$t|tj ƒr¶|j dkr¶|j dkr¶nP|d7}qDWt|tjƒrä|jrä|jdj‰n|j‰tj dkrtjd d ˆdd tjd d ˆdd g}nt d d ¡t d d ¡g}‡fdd„|Dƒ}||j||…<|g}xÌ|r&| ¡} x¶t | ¡D]¨\} } t| tƒrög} xXt| ƒD]L\} }t|tjƒrÀ|  | |¡¡n"|  |¡t|tjƒr˜| |¡q˜Wt| | | ƒn&t| tjƒrvt| tjƒsv| | ¡qvWq\WdS)z5Find all assert statements in *mod* and rewrite them.NÚ docstringr)rrFÚ __future__rÎ)rr‰Úbuiltinsz @py_builtins)réÚ col_offsetz_pytest.assertion.rewritez @pytest_arcsg|]}tj|gˆdd‘qS)r)rér)r±ÚImport)Ú.0Úalias)rér/r0ú Úsz)AssertionRewriter.run..)ÚbodyÚgetattrrvr>r±ÚExprÚvalueÚastStrrPrŽÚsÚ ImportFromÚlevelrKÚ FunctionDefZdecorator_listrér!ÚpopÚ iter_fieldsÚlistÚ enumerateÚAssertÚextendÚvisitrÑÚASTÚsetattrÚexpr)r.r}ÚdocZexpect_docstringÚposÚitemÚaliasesZimportsZnodesrúr3ÚfieldÚnewrärýr/)rér0rÅŸsl                zAssertionRewriter.run)rr"cCsd|kS)NZPYTEST_DONT_REWRITEr/)rr/r/r0rvösz%AssertionRewriter.is_rewrite_disabled)r"cCs"dtt|jƒƒ}|j |¡|S)zGet a new variable.z @py_assert)rbÚnextÚvariable_counterÚ variablesrÑ)r.r3r/r/r0Úvariableús zAssertionRewriter.variable)r5r"c Cs:| ¡}|j t t |t ¡¡g|¡¡t |t ¡¡S)zGive *expr* a name.)r?Ú statementsrÑr±ÚAssignÚNameÚStoreÚLoad)r.r5r3r/r/r0Úassigns"zAssertionRewriter.assigncCs | d|¡S)z Call saferepr on the expression.rË)Úhelper)r.r5r/r/r0ÚdisplayszAssertionRewriter.display)r3Úargsr"cGs4t dt ¡¡}t ||t ¡¡}t |t|ƒg¡S)zCall a helper in this module.z @pytest_ar)r±rBrDÚ AttributeÚCallr.)r.r3rHZpy_nameÚattrr/r/r0rF szAssertionRewriter.helper)r3r"cCs"t dt ¡¡}t ||t ¡¡S)z!Return the builtin called *name*.z @py_builtins)r±rBrDrI)r.r3Ú builtin_namer/r/r0ÚbuiltinszAssertionRewriter.builtincCs(dtt|jƒƒ}||j|<d|dS)aJReturn a new named %-formatting placeholder for expr. This creates a %-formatting placeholder for expr in the current formatting context, e.g. ``%(py0)s``. The placeholder and expr are placed in the current format context so that it can be used on the next call to .pop_format_context(). Úpyz%(z)s)rbr<r=Úexplanation_specifiers)r.r5Ú specifierr/r/r0Úexplanation_params z#AssertionRewriter.explanation_paramcCsi|_|j |j¡dS)aŒCreate a new formatting context. The format context is used for when an explanation wants to have a variable value formatted in the assertion message. In this case the value required can be added using .explanation_param(). Finally .pop_format_context() is used to format a string of %-formatted values as added by .explanation_param(). N)rOÚstackrÑ)r.r/r/r0Úpush_format_context"s z%AssertionRewriter.push_format_context)Ú expl_exprr"c Csª|j ¡}|jr|jd|_dd„| ¡Dƒ}t |t| ¡ƒ¡}t |t  ¡|¡}dt t |j ƒƒ}|j rx|j |¡|j t t |t ¡¡g|¡¡t |t ¡¡S)aZFormat the %-formatted string with current format context. The expl_expr should be an str ast.expr instance constructed from the %-placeholders created by .explanation_param(). This will add the required code to format said string to .expl_stmts and return the ast.Name instance of the formatted string. racSsg|] }t|ƒ‘qSr/)r')r Úkeyr/r/r0r":sz8AssertionRewriter.pop_format_context..z @py_format)rRr,rOÚkeysr±rr.ÚvaluesÚBinOpÚModrbr<r=rÚformat_variablesrÑÚ expl_stmtsrArBrCrD)r.rTÚcurrentrVZ format_dictÚformr3r/r/r0Úpop_format_context/s   "z$AssertionRewriter.pop_format_context)rúr"cCs.t|tjƒst‚| |¡}|| | |¡¡fS)z1Handle expressions we don't have custom code for.)r>r±r5rNrErQrG)r.rúrår/r/r0Ú generic_visitCs zAssertionRewriter.generic_visit)Úassert_r"cCs.t|jtjƒrZt|jjƒdkrZddlm}ddl}|j dk s@t ‚|j |dƒd|j |j dg|_ g|_t ¡|_|jr|g|_g|_g|_| ¡| |j¡\}}t t ¡|¡}|jr| t|ƒ¡}|jrà| d|j¡}d} n td ƒ}d } t t| ƒt ¡|¡} t |t ¡| ¡} t  d t !¡¡} | d | ¡} t "| | gg¡}t #|d¡}g}| $|j¡| %|¡| d |¡}t&|j'ƒ|j }t (| d t)|j ƒt|ƒ|¡¡}t *| d¡|j|gg¡}|g}t *|||¡}|j  %|¡|jrÂdd„|jDƒ}t +|t,dƒ¡}|j  %|¡n®|j}|j  %t *||g¡¡|jrP| d|j¡}d|}ntd ƒ}d |}t |t ¡t|ƒ¡}| |¡}| d |¡} t  d t !¡¡} t "| | gg¡}t #|d¡}| %|¡|jrödd„|jDƒ}t +|t,dƒ¡}|j  %|¡x0|j D]&}xt-|ƒD]}t .||¡q WqþW|j S)a.Return the AST statements to replace the ast.Assert instance. This rewrites the test of an assertion to provide intermediate values and replace it with an if statement which raises an assertion error with a detailed explanation in case the expression is false. rÎr)rNz5assertion is always true, perhaps remove parentheses?)Úcategoryr­rérÔz >assert rqzassert rNÚ_format_explanationrìrícSsg|]}t |t ¡¡‘qSr/)r±rBrC)r r3r/r/r0r"›sz2AssertionRewriter.visit_Assert..cSsg|]}t |t ¡¡‘qSr/)r±rBrC)r r3r/r/r0r"µs)/r>Útestr±r r½Úeltsr‚rÚwarningsrÄrNÚ warn_explicitrér@r>Ú itertoolsÚcountr=rrZrRr[rSr2ÚUnaryOpÚNotr^r'ÚmsgrFrXÚAddrBrDrJÚRaiser1rÑrrµr%ÚastNumÚIfrAÚastNameConstantrüÚ copy_location)r.r`rreZ top_conditionrÜZnegationrkZ assertmsgZgluestrZerr_explanationÚerr_msgZerr_nameÚfmtÚexcZraise_Zstatements_failZfmt_passrêZhook_call_passZhook_impl_testZstatements_passZ main_testr>Z clear_formatr#Útemplater|Ústmtrúr/r/r0Ú visit_AssertIsš                 zAssertionRewriter.visit_AssertcCs|t | d¡gg¡}|jj}t t|ƒt ¡g|g¡}| d|¡}t  t  ¡||g¡}t  ||  |¡t|ƒ¡}||  |¡fS)NÚlocalsr×)r±rJrMr5ÚidÚComparer'ÚInrFÚBoolOpÚOrÚIfExprGrQ)r.r3ÚlocsZ target_idÚinlocsÚdoreprrcr5r/r/r0Úvisit_NamedExpr¾s z!AssertionRewriter.visit_NamedExprcCsxt | d¡gg¡}t t|jƒt ¡g|g¡}| d|¡}t t  ¡||g¡}t  ||  |¡t|jƒ¡}||  |¡fS)Nrxr×) r±rJrMrzr'ryr{rFr|r}r~rGrQ)r.r3rr€rrcr5r/r/r0Ú visit_NameÊs  zAssertionRewriter.visit_Name)Úboolopr"c Csü| ¡}| t gt ¡¡¡}t |dt ¡¡}tt|jtj ƒƒ}|j }}|j }t |j ƒd} | ¡xNt|j ƒD]>\} } | r g} |j  t | | g¡¡| |_ t| tjƒr t| jtƒr | jjjdd„|j d| …Dƒkr | ¡}| j|j| jjj<|| jj_| ¡| | ¡\}}| t t |t ¡¡g|¡¡| t|ƒ¡}t ||gg¡}|j  t |¡¡| | krv|} |r’t  t !¡| ¡} g}|j  t | |g¡¡||_ }qvW||_ ||_ | "d|t#|ƒ¡}| |¡}t |t ¡¡| $|¡fS)NrÑrÎcSsg|]}t|dƒr|j‘qS)ry)rÖry)r Zast_exprr/r/r0r"êsz2AssertionRewriter.visit_BoolOp..rÝ)%r?rEr±r rDrIrœr>Úopr}r@r[r½rWrSr/rÑrorzÚleftÚ namedExprr5ryrr2rArBrCr^r'rJr%rirjrFrnrQ)r.r„Zres_varZ expl_listZapprÙr#ÚsaveZ fail_saveZlevelsräÚvZ fail_innerZcondZ pytest_tempråræZ expl_formatÚcallÚinnerZ expl_templater/r/r0Ú visit_BoolOpÔsN    zAssertionRewriter.visit_BoolOp)Úunaryr"cCs>t|jj}| |j¡\}}| t |j|¡¡}|||ffS)N)Ú UNARY_MAPr…rr2ÚoperandrEr±ri)r.rÚpatternZ operand_resZ operand_explrår/r/r0Ú visit_UnaryOps zAssertionRewriter.visit_UnaryOp)Úbinopr"c Csbt|jj}| |j¡\}}| |j¡\}}d|›d|›d|›d}| t ||j|¡¡}||fS)NrÚú rm) Ú BINOP_MAPr…rr2r†ÚrightrEr±rX) r.r’ÚsymbolZ left_exprÚ left_explZ right_exprZ right_explrÜrår/r/r0Ú visit_BinOp s  zAssertionRewriter.visit_BinOp)rŠr"cCsT| |j¡\}}g}g}g}xT|jD]J}t|tjƒrL|j|jkrL|j|j}| |¡\}} | | ¡| |¡q$Wxˆ|j D]~} t| j tjƒrª| j j|jkrª|j| j j| _ | | j ¡\}} | t  | j |¡¡| j rê| | j d| ¡qz| d| ¡qzWd  |d |¡¡} t |||¡} | | ¡}| | |¡¡} | ›d| ›d| ›d} || fS)Nú=z**z{}({})z, z {z = z })r2ÚfuncrHr>r±rBryrrÑÚkeywordsr&ÚkeywordÚargÚformatrÛrJrErQrG)r.rŠÚnew_funcZ func_explZ arg_explsÚnew_argsZ new_kwargsrrårærœZnew_callÚres_explZ outer_explr/r/r0Ú visit_Calls4      zAssertionRewriter.visit_Call)Ústarredr"cCs*| |j¡\}}t ||j¡}|d|fS)Nró)r2r&r±ÚStarredÚctx)r.r£råræZ new_starredr/r/r0Ú visit_Starred6szAssertionRewriter.visit_Starred)rKr"cCspt|jtjƒs| |¡S| |j¡\}}| t ||j t ¡¡¡}|  |  |¡¡}d}|||||j f}||fS)Nz%s {%s = %s.%s }) r>r¥r±rDr_r2r&rErIrKrQrG)r.rKr&Z value_explrår¡rkrær/r/r0Úvisit_Attribute<s z!AssertionRewriter.visit_Attribute)Úcompr"c s`ˆ ¡t|jtjƒr4|jjˆjkr4ˆj|jj|_t|jtƒrR|jˆj|jjj<ˆ  |j¡\}}t|jtj tj fƒr‚d|›d}‡fdd„t t |jƒƒDƒ}dd„|Dƒ}dd„|Dƒ}tt t |jƒƒ|j|jƒ}g}g} |g} xü|D]ô\} } } t| tƒr4t|tjƒr4| jj|jkr4ˆ ¡| j_| ˆj|j<ˆ  | ¡\}}t| tj tj fƒrbd|›d}|  |¡t| j}|  t|ƒ¡|›d|›d|›}| t|ƒ¡t  || g|g¡}ˆj t || g|¡¡||}}qèWˆ dt | t ¡¡t |t ¡¡t |t ¡¡t | t ¡¡¡}t |jƒd krDt  t ¡|¡}n|d }|ˆ ˆ |¡¡fS) NrÚrmcsg|] }ˆ ¡‘qSr/)r?)r rä)r.r/r0r"Tsz3AssertionRewriter.visit_Compare..cSsg|]}t |t ¡¡‘qSr/)r±rBrD)r r‰r/r/r0r"UscSsg|]}t |t ¡¡‘qSr/)r±rBrC)r r‰r/r/r0r"Vsr“rèrÎr)rSr>r†r±rBryrr‡r5r2rzr|rãr½rÞrâZ comparatorsr?rÑr”rr'r@rArFr rDÚAndrQr^)r.r¨Zleft_resr—Z res_variablesZ load_namesZ store_namesÚitràZsymsrßrär…Z next_operandZnext_resZ next_explÚsymræZres_exprZ expl_callrår/)r.r0Ú visit_CompareFsV         zAssertionRewriter.visit_Compare)2rOr’r“rwr rbrr•r1r±ÚModulerÅÚ staticmethodr˜rvr?r5rBrErGrFrIrMrQrSr^r3r r_r0r rvrwr‡r‚rƒr|rŒrir‘rXr˜rJr¢r¤r¦r§rzr¬Ú __classcell__r/r/)rr0ruWs27 W  u  3! ru)r[r"c Csvytj|ddWn^tttfk r,dStk r>dStk rp}z|jtjkr^dS‚Wdd}~XYnXdS)z~Attempt to create the given directory and sub-directories exist. Returns True if successful or if it already exists. T)Úexist_okFN) rBÚmakedirsÚFileNotFoundErrorÚNotADirectoryErrorÚFileExistsErrorÚPermissionErrorr©rªZEROFS)r[r¬r/r/r0rS€s rS)Ú file_pathr"cCs:tjdkr,tjr,ttjƒt|jdd…ŽS|jdSdS)zKReturn the cache directory to write .pyc files for the given .py file path.)rrrÎraÚ __pycache__N)rPrŽZpycache_prefixrrjÚparent)r¶r/r/r0rR–srR)NN)ƒrwr±rªÚ functoolsr™r?Úimportlib.machineryÚimportlib.utilr rgr¡rBrŸrPr rÚpathlibrrÚtypingrrrrrr r r r r rrZ_pytest._io.safereprrrZ_pytest._versionrZ_pytest.assertionrZ_pytest.assertion.utilrrbZ_pytest.configrZ _pytest.mainrZ_pytest.pathlibrrZ _pytest.stashrrrŽZ NamedExprr‡ÚConstantrpr'rnr%Ú NameConstantÚStrÚNumr9ÚimplementationÚ cache_tagZ PYTEST_TAGZPYC_EXTrTÚabcÚMetaPathFinderÚLoaderr r•rÂrÁr¦r˜rWrVrbrUr­r³ÚobjectrËrœrÉrÔr×rÝrèrìrírjÚInvertÚUSubÚUAddrŽÚBitOrÚBitXorÚBitAndÚLShiftÚRShiftrlÚSubÚMultÚDivÚFloorDivrYÚEqÚNotEqÚLtÚLtEÚGtÚGtEÚPowÚIsÚIsNotr{ÚNotInÚMatMultr”r3rüÚ lru_cacherÚ NodeVisitorrurSrRr/r/r/r0Úsä                            n 2    6-