o ¶úåhü½ã @s˜dZddlmZddlZddlmZddlmZddlmZddlm Z ddlm Z ddl Z ddl Z ddl ZddlZddlZddlZddlZddlZddlZdd lmZdd lmZddlZddlZddlZddlZdd lmZdd lmZdd lm Z ddlm!Z!ddlm"Z"ddl#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.ddl-m/Z/ddl0m1Z1ddl2m3Z4erÆddl%m5Z5Gdd„dƒZ6e1dƒZ7ej8j9›de$›Z:dd pßd!Z;d"e:e;Zj?ej>j@ƒZAd›d-d.„ZBdœd3d4„ZCdd9d:„ZDd;d<„fdždAdB„ZE  dŸd dIdJ„ZFd¡dNdO„ZGd¢dQdR„ZHd¡dSdT„ZId£dUdV„ZJd¤dZd[„ZKd¥dcdd„ZLd¦didj„ZMd§dkdl„ZNejOdmejPdnejQdoejRdpiZSiejTdq“ejUdr“ejVds“ejWdt“ejXdu“ejYdv“ejZdw“ej[dx“ej\dy“ej]dz“ej^d{“ej_d|“ej`d}“ejad~“ejbd“ejcd€“ejdd“ejed‚ejfdƒejgd„ejhd…ejid†ejjd‡i¥Zkd¨d‹dŒ„Zle jmddŽd©d‘d’„ƒZnGd“d”„d”ejoƒZpdªd–d—„Zqd«d™dš„ZrdS)¬z5Rewrite assertion AST to produce nice error messages.é)Ú annotationsN)Ú defaultdict)ÚCallable)ÚIterable)ÚIterator)ÚSequence)ÚPath)ÚPurePath)ÚIO)Ú TYPE_CHECKING)ÚDEFAULT_REPR_MAX_SIZE)Úsaferepr)Úsaferepr_unlimited)Úversion)Úutil)ÚConfig)ÚFixtureFunctionDefinition)ÚSession)Ú absolutepath)Ú fnmatch_ex)ÚStashKey)Úformat_explanation)ÚAssertionStatec@s eZdZdS)ÚSentinelN)Ú__name__Ú __module__Ú __qualname__©rrúZ/var/www/html/openai_agents/venv/lib/python3.10/site-packages/_pytest/assertion/rewrite.pyr2srrz-pytest-ú.pyTÚcÚoÚ.c@sÊeZdZdZd9dd„Zd:d d „Zejjj Z d;ddd„Z d?d!d"„Z d@d$d%„Zd?d&d'„ZdAd)d*„ZdBd+d,„ZdCd0d1„Zejd2krcejd3krVd4d5lmZnd4d5lmZdDd7d8„Zd Sd S)EÚAssertionRewritingHookz1PEP302/PEP451 import hook which rewrites asserts.ÚconfigrÚreturnÚNonecCsf||_z| d¡|_Wntyddg|_Ynwd|_i|_tƒ|_d|_dh|_ i|_ d|_ dS)NÚ python_filesz test_*.pyz *_test.pyFÚconftest) r$ÚgetiniÚfnpatsÚ ValueErrorÚsessionÚ_rewritten_namesÚsetÚ _must_rewriteÚ _writing_pycÚ_basenames_to_check_rewriteÚ_marked_for_rewrite_cacheÚ_session_paths_checked)Úselfr$rrrÚ__init__Ds ÿ zAssertionRewritingHook.__init__r,úSession | NonecCs||_d|_dS)NF)r,r3)r4r,rrrÚ set_sessionTs z"AssertionRewritingHook.set_sessionNÚnameÚstrÚpathúSequence[str | bytes] | NoneÚtargetútypes.ModuleType | Noneú%importlib.machinery.ModuleSpec | NonecCsØ|jrdS|jjt}| ||¡rdS| d|›¡| ||¡}|dur;|dur;|D]}tj  ||¡}|dur:nq+|dusS|j dusSt |j tj jƒrStj |j ¡sUdS|j }| |||¡sadStjj ||||jdS)Nzfind_module called for: )ÚloaderÚsubmodule_search_locations)r0r$ÚstashÚassertstate_keyÚ_early_rewrite_bailoutÚtraceÚ _find_specÚ importlibrÚspec_from_file_locationÚoriginÚ isinstancer?Ú machineryÚSourceFileLoaderÚosr:ÚexistsÚ_should_rewriter@)r4r8r:r<ÚstateÚspecÚ _path_strÚfnrrrÚ find_spec[s:   ÿ þ üüz AssertionRewritingHook.find_specrPúimportlib.machinery.ModuleSpeccCódS©Nr)r4rPrrrÚ create_modulesz$AssertionRewritingHook.create_moduleÚmoduleútypes.ModuleTypec Cs|jdusJ‚|jjdusJ‚t|jjƒ}|jjt}||j|j<tj }t |ƒ}|r;t |ƒ}|s;d}|  d|›¡|j dd…t}||}t|||j ƒ} | durz|  d|›¡t||jƒ\} } |ryd|_z t|| | |ƒWd|_n d|_wn|  d|›¡t| |jƒdS)NFzread only directory: éýÿÿÿz rewriting Tzfound cached rewritten pyc for )Ú__spec__rHrr$rArBr-rÚsysÚdont_write_bytecodeÚ get_cache_dirÚ try_makedirsrDr8ÚPYC_TAILÚ _read_pycÚ _rewrite_testr0Ú _write_pycÚexecÚ__dict__) r4rXrRrOÚwriteÚ cache_dirÚokÚ cache_nameÚpycÚcoÚ source_statrrrÚ exec_module’s4    ûz"AssertionRewritingHook.exec_modulerOrÚboolcCsÌ|jdur(|js(d|_|jjD]}t|ƒ tj¡}|j tj   |d¡d¡q| d¡}|d|jvr6dSt |Ž  d¡}|j D]}tj  |¡rKdSt||ƒrSdSq@| ||¡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éÿÿÿÿrr"Frz early skip of rewriting module: )r,r3Ú _initialpathsr9ÚsplitrLÚsepr1Úaddr:Úsplitextr Ú with_suffixr*ÚdirnamerÚ_is_marked_for_rewriterD)r4r8rOÚ initial_pathÚpartsr:ÚpatrrrrC¼s&     ÿ z-AssertionRewritingHook._early_rewrite_bailoutrRcCs’tj |¡dkr| d|›¡dS|jdur)|j t|ƒ¡r)| d|›¡dSt|ƒ}|jD]}t ||ƒrB| d|›¡dSq0|  ||¡S)Nz conftest.pyzrewriting conftest file: Tz.matched test file (was specified on cmdline): zmatched test file ) rLr:ÚbasenamerDr,Ú isinitpathrr r*rrw)r4r8rRrOÚfn_pathrzrrrrNãs   þ z&AssertionRewritingHook._should_rewritec Csxz|j|WSty;|jD]"}||ks| |d¡r2| d|›d|›d¡d|j|<YdSqd|j|<YdSw)Nr"zmatched marked file z (from ú)TF)r2ÚKeyErrorr/Ú startswithrD)r4r8rOÚmarkedrrrrwøs    ý øz-AssertionRewritingHook._is_marked_for_rewriteÚnamescGspt|ƒ tj¡ |j¡}|D]}tj|}t |jpd¡s*t |j t |ƒƒs*|  |¡q|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.Ú intersectionr\ÚmodulesÚ differencer-ÚAssertionRewriterÚis_rewrite_disabledÚ__doc__rIÚ __loader__ÚtypeÚ_warn_already_importedr/Úupdater2Úclear)r4r‚Úalready_importedr8ÚmodrrrÚ mark_rewritesÿ ÿþ € z#AssertionRewritingHook.mark_rewritecCs*ddlm}|jj|d|›ƒdddS)Nr©ÚPytestAssertRewriteWarningz0Module already imported so cannot be rewritten; é)Ú stacklevel)Ú_pytest.warning_typesr“r$Úissue_config_time_warning)r4r8r“rrrrŒs ÿ üz-AssertionRewritingHook._warn_already_importedÚpathnameú str | bytesÚbytescCs6t|dƒ }| ¡WdƒS1swYdS)zOptional PEP302 get_data API.ÚrbN)ÚopenÚread)r4r˜ÚfrrrÚget_data!s $ÿzAssertionRewritingHook.get_data©éé )r¡é r)ÚTraversableResourcesr¤cCs:tjdkr ddlm}nddlm}|tj|j|dƒS)N)r¡é r)Ú FileReader)r:)r\Ú version_infoÚimportlib.readersr¦Úimportlib.resources.readersÚtypesÚSimpleNamespacer-)r4r8r¦rrrÚget_resource_reader,s  z*AssertionRewritingHook.get_resource_reader)r$rr%r&)r,r6r%r&©NN)r8r9r:r;r<r=r%r>)rPrTr%r=)rXrYr%r&)r8r9rOrr%rn)r8r9rRr9rOrr%rn)r‚r9r%r&)r8r9r%r&)r˜r™r%rš)r8r9r%r¤)rrrr‰r5r7rFrJÚ PathFinderrSrErWrmrCrNrwr‘rŒrŸr\r§Úimportlib.resources.abcr¤Ú importlib.abcr¬rrrrr#As,    ü 2  * '     úr#Úfpú IO[bytes]rlúos.stat_resultrkútypes.CodeTyper%r&cCs\| tjj¡d}| |¡t|jƒd@}|jd@}| t d||¡¡| t   |¡¡dS)Nóìÿÿzlsr×rÓrDúCallable[[str], None]útypes.CodeType | Nonec Csfzt|dƒ}Wn tyYdSw|zt |¡}t|jƒ}|j}| d¡}Wn#tyM}z|d|›d|›ƒWYd}~WdƒdSd}~wwt|ƒdkre|d|›dƒ WdƒdS|dd…t j j kr€|d|›dƒ WdƒdS|dd …d kr™|d|›d ƒ WdƒdS|d d …} t  | d ¡|d@krº|d|›dƒ WdƒdS|d d…} t  | d ¡|d@krÛ|d|›dƒ WdƒdSzt  |¡} Wn$ty}z|d|›d|›ƒWYd}~WdƒdSd}~wwt| tjƒs|d|›dƒ WdƒdS| WdƒS1s,wYdS)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): invalid pyc (too short)éz!): invalid pyc (bad magic number)érµz"): invalid pyc (unsupported flags)r£Úlittler¶z): out of datez): invalid pyc (incorrect size)z): marshal.load error z): not a code object)rœrÅrLrÍr¸r¹rºrÚlenrFrr·Ú from_bytesr½ÚloadÚ ExceptionrIrªÚCodeType) rÓrjrDr±Ú stat_resultrÀrÁÚdatarÉÚ mtime_dataÚ size_datarkrrrraksj ÿ   ø€ ô ñî ê æ á€Þ#&Ýrarú ast.ModuleršÚ module_pathú str | Noneú Config | NonecCst|||ƒ |¡dS)z%Rewrite the assert statements in mod.N)r‡Úrun)rrÓrèr$rrrrÑœsrÑÚobjÚobjectr9cCsDt|tjƒr |jSttjƒ}|st|ƒ dd¡St ||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. Ú ú\n©Úmaxsize) rIrªÚ MethodTyperÚ_get_maxsize_for_safereprrÚ_configrrÇr )rìrñrrrÚ _saferepr¦s  rõú int | NonecCs:|durd}n| tj¡}|dkrdS|dkrtdStS)zJGet `maxsize` configuration for saferepr based on the given config object.Nréér¢)Ú get_verbosityrÚVERBOSITY_ASSERTIONSr )r$Ú verbosityrrrróºs rócCsJddg}t|tƒst|ttjƒƒ}| d¡|D] \}}| ||¡}q|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îú ~)ú%ú%%)rïrü)rIr9r rórrôÚappendrÇ)rìÚreplacesÚr1Úr2rrrÚ_format_assertmsgÇs   rcCs6t|ƒr t|tƒSzt|dƒ WStyYdSw)NrT)ÚcallablerIrÚhasattrrá)rìrrrÚ_should_repr_global_nameÝs  ÿrÚ explanationsú Iterable[str]Úis_orcCs&d|rdpd |¡d}| dd¡S)Nú(z or z and r~rýrþ)ÚjoinrÇ)rr Ú explanationrrrÚ_format_boolopès r Úopsú Sequence[str]ÚresultsúSequence[bool]ÚexplsÚeach_objúSequence[object]c Cs‚ttt|ƒƒ||ƒD]\}}}z| }Wn tyd}Ynw|r$nq tjdur?t ||||||d¡}|dur?|S|S)NTrø)ÚzipÚrangerÞrárÚ _reprcompare) rrrrÚiÚresÚexplÚdoneÚcustomrrrÚ_call_reprcompareís  ÿÿ rÚlinenor¸ÚorigrcCs tjdurt |||¡dSdSrV©rÚ_assertion_pass)rrrrrrÚ_call_assertion_passs ÿr"cCstjrdSdS)zŠCheck if any plugins implement the pytest_assertion_pass hook in order not to generate explanation unnecessarily (might be expensive).TFr rrrrÚ_check_if_assertion_pass_implsr#znot %sz~%sz-%sz+%sú|ú^ú&z<>ú+ú-Ú*ú/z//rþz==z!=úz>=ú**Úiszis notÚinznot inú@Únodeúast.ASTúIterator[ast.AST]ccs*|Vt |¡D] }t|ƒEdHq dS)zARecursively yield node and all its children in depth-first order.N)rÏÚiter_child_nodesÚ traverse_node)r1Úchildrrrr5)s €ÿr5rørðÚsrcúdict[int, str]c sži‰d‰g‰d‰tƒ‰d ‡‡‡‡‡fdd„ }t t |¡j¡}|D]«\}}\}}}}|tjkr6|dkr6|‰q!ˆdurÌ|tjkrH|dvrHˆd 7‰n |tjkrU|d vrUˆd 8‰ˆsfˆ ||d…¡ˆ |¡q!ˆdkr°|tjkr°|d kr°|ˆvr”t ˆƒd kr”|t ˆd ƒt |ƒ} ˆd d| …ˆd <n|ˆvr£ˆd d|…ˆd <n ˆ |d|…¡|ƒq!|tj tj hvr¼|ƒq!ˆrÌ|ˆvr̈ |¡ˆ |¡q!ˆS)z._write_and_resetÚassertz([{røz)]}ú,ro©r%r&) r.ÚtokenizeÚioÚBytesIOÚreadlineÚNAMEÚOPrÿrsrÞÚNEWLINEÚ ENDMARKER) r7rAÚtokensÚtprÓrÚoffsetÚ_ÚlineÚoffset_in_trimmedrr;rÚ_get_assertion_exprs0sB      €rScsøeZdZdZdY‡fd d „ ZdZdd„Zed[dd„ƒZd\dd„Zd]dd„Z d^dd„Z d_d d!„Z d`d#d$„Z dad%d&„Z dbd'd(„Zdcd*d+„Zddd/d0„Zded4d5„Zdfd8d9„Zdgd:d;„Zdhd>d?„ZdidBdC„ZdjdFdG„ZdkdJdK„ZdldOdP„ZdmdRdS„ZdndWdX„Z‡ZS)or‡aÜ 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. :scope: A tuple containing the current scope used for variables_overwrite. :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. rèrér$rêrÓršr%r&csLtƒ ¡||_||_|dur| d¡|_nd|_||_d|_tt ƒ|_ dS)NÚenable_assertion_pass_hookFr) Úsuperr5rèr$r)rTrÓÚscoperÚdictÚvariables_overwrite)r4rèr$rÓ©Ú __class__rrr5¢s ÿÿzAssertionRewriter.__init__rrçcs‚|jsdSt|ddƒ}|du}|dur| |¡rdSd}d}|jD]>}|rHt|tjƒrHt|jtjƒrHt|jjtƒrH|jj}| |¡rEdSd}nt|tj ƒrY|j dkrY|j dkrYnn|d7}q!t|tj ƒrp|j rp|j dj‰n|j‰tjdkr‹tjdd ˆdd tjd d ˆdd g}n t dd ¡t d d ¡g}‡fd d„|Dƒ}||j||…<|f|_|g}|r?| ¡} t| tj tjtjfƒrÐtg|j¢| ‘Rƒ|_| t¡| tkrÝ|jdd…|_q®t| tjƒsåJ‚t | ¡D]P\} } t| tƒr'g} t| ƒD]%\} }t|tjƒr|  | |¡¡qú|  |¡t|tjƒr| |¡qút | | | ƒqêt| tjƒr:t| tj!ƒs:| | ¡qê|s±dSdS)z5Find all assert statements in *mod* and rewrite them.NÚ docstringrFÚ __future__rør Úbuiltinsú @py_builtins©rÚ col_offsetz_pytest.assertion.rewriteú @pytest_arcsg|] }tj|gˆdd‘qS)rr_)rÏÚImport)Ú.0Úalias©rrrÚ ìsÿz)AssertionRewriter.run..ro)"ÚbodyÚgetattrrˆrIrÏÚExprÚvalueÚConstantr9Ú ImportFromÚlevelrXÚ FunctionDefÚdecorator_listrr\r§rdrVÚpopÚAsyncFunctionDefÚClassDefÚtuplerÿÚ_SCOPE_END_MARKERÚASTÚ iter_fieldsÚlistÚ enumerateÚAssertÚextendÚvisitÚsetattrÚexpr)r4rÚdocÚexpect_docstringÚposÚitemÚaliasesÚimportsÚnodesr1r8ÚfieldÚnewrr6rrerrë´s˜  ÿ þ ý ü  ÿ    üþ þ ÿ    € ÿ ü € åzAssertionRewriter.runr[r9rncCsd|vS)NÚPYTEST_DONT_REWRITEr)r[rrrrˆsz%AssertionRewriter.is_rewrite_disabledcCs"dtt|jƒƒ}|j |¡|S)zGet a new variable.z @py_assert)r9ÚnextÚvariable_counterÚ variablesrÿ)r4r8rrrÚvariables zAssertionRewriter.variabler}úast.exprúast.Namec CsB| ¡}|j t t |t ¡¡g|¡¡t t |t ¡¡|¡S)zGive *expr* a name.) r‹Ú statementsrÿrÏÚAssignÚNameÚStoreÚ copy_locationÚLoad)r4r}r8rrrÚassigns"zAssertionRewriter.assigncCs | d|¡S)z Call saferepr on the expression.rõ)Úhelper)r4r}rrrÚdisplay"s zAssertionRewriter.displayr8ÚargscGs4t dt ¡¡}t ||t ¡¡}t |t|ƒg¡S)zCall a helper in this module.ra)rÏrr“Ú AttributeÚCallrw)r4r8r—Úpy_nameÚattrrrrr•&szAssertionRewriter.helperú ast.AttributecCs"t dt ¡¡}t ||t ¡¡S)z!Return the builtin called *name*.r^)rÏrr“r˜)r4r8Ú builtin_namerrrÚbuiltin,szAssertionRewriter.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)r9rˆr‰Úexplanation_specifiers)r4r}Ú specifierrrrÚexplanation_param1s  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)r Ústackrÿ©r4rrrÚpush_format_context=s z%AssertionRewriter.push_format_contextÚ expl_exprc Csª|j ¡}|jr|jd|_dd„| ¡Dƒ}t |t| ¡ƒ¡}t |t  ¡|¡}dt t |j ƒƒ}|j r<|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. rocSsg|]}t |¡‘qSr)rÏrk)rcÚkeyrrrrfUsz8AssertionRewriter.pop_format_context..z @py_format)r£rpr ÚkeysrÏÚDictrwÚvaluesÚBinOpÚModr9rˆr‰rTÚformat_variablesrÿÚ expl_stmtsrrr‘r“)r4r¦Úcurrentr¨Ú format_dictÚformr8rrrÚpop_format_contextJs   "z$AssertionRewriter.pop_format_contextr1r2útuple[ast.Name, str]cCs.t|tjƒsJ‚| |¡}|| | |¡¡fS)z1Handle expressions we don't have custom code for.)rIrÏr}r”r¢r–)r4r1rrrrÚ generic_visit^s zAssertionRewriter.generic_visitÚassert_ú ast.Assertúlist[ast.stmt]c CsLt|jtjƒr-t|jjƒdkr-ddl}ddlm}|j dus J‚|j |dƒd|j |j dg|_ g|_ t ¡|_|jr>g|_g|_g|_| ¡| |j¡\}}t t ¡|¡}|jr| t |¡¡}|jrq| d|j¡}d} nt d ¡}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¡g|j¢|‘g¡}|g}t (|||¡}|j  $|¡|jrdd„|jDƒ}t )|t d¡¡}|j  $|¡nY|j}|j  $t (||g¡¡|jr/| d|j¡}d|}n t d ¡}d |}t |t ¡t |¡¡}| |¡}| d |¡} t d t  ¡¡} t !| | gg¡}t "|d¡}| $|¡|j r…dd„|j Dƒ}t )|t d¡¡}|j  $|¡|j D]}t*|ƒD]}t+|ddƒdurŸt ,||¡qŽqˆ|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ørNr’z5assertion is always true, perhaps remove parentheses?)ÚcategoryrËrrz >assert rƒzassert ÚAssertionErrorÚ_format_explanationr"r#cSóg|] }t |t ¡¡‘qSr©rÏrr‘©rcr8rrrrf¶sÿz2AssertionRewriter.visit_Assert..cSr»rr¼r½rrrrfÑór)-rIÚtestrÏÚTuplerÞÚeltsÚwarningsr–r“rèÚ warn_explicitrrŽrŠÚ itertoolsÚcountr‰rTr­r£r®r¥r{ÚUnaryOpÚNotr²rkÚmsgr•r«ÚAddrr“r™ÚRaiserzrÿrSrÓriÚIfrr5rhr’)r4rµrÂr“Ú top_conditionr ÚnegationrÈÚ assertmsgÚgluestrÚerr_explanationÚerr_msgÚerr_nameÚfmtÚexcÚraise_Ústatements_failÚfmt_passrÚhook_call_passÚhook_impl_testÚstatements_passÚ main_testrŠÚ clear_formatrgÚtemplaterŽÚstmtr1rrrÚ visit_Assertds° ÿú         üÿ  ý ÿ €          €üzAssertionRewriter.visit_Assertú ast.NamedExprútuple[ast.NamedExpr, str]cCs€t | d¡gg¡}|jj}t t |¡t ¡g|g¡}| d|¡}t  t  ¡||g¡}t  ||  |¡t |¡¡}||  |¡fS©NÚlocalsr)rÏr™ržr<ÚidÚComparerkÚInr•ÚBoolOpÚOrÚIfExpr–r¢)r4r8ÚlocsÚ target_idÚinlocsÚdoreprr¿r}rrrÚvisit_NamedExprÝs z!AssertionRewriter.visit_NamedExprcCs|t | d¡gg¡}t t |j¡t ¡g|g¡}| d|¡}t t  ¡||g¡}t  ||  |¡t |j¡¡}||  |¡fSrâ) rÏr™ržrårkrärær•rçrèrér–r¢)r4r8rêrìrír¿r}rrrÚ visit_Nameés  zAssertionRewriter.visit_NameÚboolopú ast.BoolOpc Csö| ¡}| t gt ¡¡¡}t |dt ¡¡}tt|jtj ƒƒ}|j }}|j }t |j ƒd} | ¡t|j ƒD]Ÿ\} } | r‚g} |j  t | | g¡¡| |_ t| tjƒr‚t| jtjƒr‚| jjjdd„|j d| …Dƒvr‚| ¡}| j|j|j| jjj<|| jj_| ¡| | ¡\}}| t t |t ¡¡g|¡¡| t |¡¡}t ||gg¡}|j  t  |¡¡| | krØ|} |rÆt !t "¡| ¡} g}|j  t | |g¡¡||_ }q9||_ ||_ | #d|t |¡¡}| |¡}t |t ¡¡| $|¡fS)NrÿrøcSsg|] }t|dƒr|j‘qS)rä)rrä)rcÚast_exprrrrrfs ýÿz2AssertionRewriter.visit_BoolOp..r )%r‹r”rÏÚListr“r˜r¸rIÚoprèrŽr®rÞrªr¥rxrÿrËråÚleftÚ NamedExprr<rärXrVr{rrr‘r²rkr™rirÆrÇr•r¢)r4rðÚres_varÚ expl_listÚappr rgÚsaveÚ fail_saveÚlevelsrÚvÚ fail_innerÚcondÚ pytest_temprrÚ expl_formatÚcallÚinnerÚ expl_templaterrrÚ visit_BoolOpósX  ÿ þ þÿ   € zAssertionRewriter.visit_BoolOpÚunaryú ast.UnaryOpcCsFt|jj}| |j¡\}}| t t |j|¡|¡¡}|||ffSrV) Ú UNARY_MAPrôrZr{Úoperandr”rÏr’rÆ)r4rÚpatternÚ operand_resÚ operand_explrrrrÚ visit_UnaryOp$s zAssertionRewriter.visit_UnaryOpÚbinopú ast.BinOpc Csjt|jj}| |j¡\}}| |j¡\}}d|›d|›d|›d}| t t  ||j|¡|¡¡}||fS)Nr ú r~) Ú BINOP_MAPrôrZr{rõÚrightr”rÏr’r«) r4rÚsymbolÚ left_exprÚ left_explÚ right_exprÚ right_explr rrrrÚ visit_BinOp*s ÿzAssertionRewriter.visit_BinOprúast.CallcCst| |j¡\}}g}g}g}|jD]-}t|tjƒr-|j|j |j i¡vr-|j|j |j}| |¡\}} |  | ¡|  |¡q|j D]G} t| j tjƒrb| j j|j |j i¡vrb|j|j | j j| _ | | j ¡\}} |  t  | j|¡¡| jr‚|  | jd| ¡qB|  d| ¡qBd |d |¡¡} t t |||¡|¡} | | ¡}| | |¡¡} | ›d| ›d| ›d} || fS)Nú=r-z{}({})z, z {z = z })r{Úfuncr—rIrÏrrärXÚgetrVrÿÚkeywordsrjÚkeywordÚargÚformatr r’r™r”r¢r–)r4rÚnew_funcÚ func_explÚ arg_explsÚnew_argsÚ new_kwargsrrrrÚnew_callÚres_explÚ outer_explrrrÚ visit_Call4s: ÿ   ÿ zAssertionRewriter.visit_CallÚstarredú ast.Starredútuple[ast.Starred, str]cCs*| |j¡\}}t ||j¡}|d|fS)Nr))r{rjrÏÚStarredÚctx)r4r*rrÚ new_starredrrrÚ visit_StarredTs zAssertionRewriter.visit_Starredr›c Csxt|jtjƒs | |¡S| |j¡\}}| t t  ||j t ¡¡|¡¡}|  |  |¡¡}d}|||||j f}||fS)Nz%s {%s = %s.%s }) rIr.rÏr“r´r{rjr”r’r˜r›r¢r–)r4r›rjÚ value_explrr'rzrrrrÚvisit_AttributeZs ÿz!AssertionRewriter.visit_AttributeÚcompú ast.Compareútuple[ast.expr, str]c s€ˆ ¡t|jtjƒr"|jjˆj ˆji¡vr"ˆjˆj|jj|_t|jtj ƒr5|jˆjˆj|jj j<ˆ  |j¡\}}t|jtj tj fƒrMd|›d}‡fdd„tt|jƒƒDƒ}dd„|Dƒ}dd„|Dƒ}ttt|jƒƒ|j|jƒ}g}g} |g} |D]€\} } } t| tj ƒr¦t|tjƒr¦| j j|jkr¦ˆ ¡| j _| ˆjˆj|j<ˆ  | ¡\}}t| tj tj fƒr¼d|›d}|  |¡t| j}|  t |¡¡|›d|›d|›}| t |¡¡t t  || g|g¡|¡}ˆj t || g|¡¡||}}qˆ dt | t ¡¡t |t ¡¡t |t ¡¡t | t ¡¡¡}t|jƒd kr2t  t ¡|¡}n|d }|ˆ ˆ  |¡¡fS) Nr r~csg|]}ˆ ¡‘qSr)r‹)rcrr¤rrrfrsz3AssertionRewriter.visit_Compare..cSr»r)rÏrr“©rcrýrrrrfsr¾cSr»rr¼r6rrrrftr¾rrrør)!r¥rIrõrÏrrärXrrVrör<r{rårçrrÞrrÚ comparatorsr‹rÿrrZrkr’rŽrr•rÀr“ÚAndr¢r²)r4r3Úleft_resrÚ res_variablesÚ load_namesÚ store_namesÚitrÚsymsrrrôÚ next_operandÚnext_resÚ next_explÚsymrÚres_exprÚ expl_callrrr¤rÚ visit_Comparefs`ÿ  ÿ þ     ûzAssertionRewriter.visit_Compare)rèrér$rêrÓršr%r&)rrçr%r&)r[r9r%rn)r%r9)r}rŒr%r)r}rŒr%rŒ)r8r9r—rŒr%rŒ)r8r9r%rœ)r}rŒr%r9rD)r¦rŒr%r)r1r2r%r³)rµr¶r%r·)r8ràr%rá)r8rr%r³)rðrñr%r³)rrr%r³)rrr%r³)rrr%r³)r*r+r%r,)r›rœr%r³)r3r4r%r5)rrrr‰r5rëÚ staticmethodrˆr‹r”r–r•ržr¢r¥r²r´rßrîrïrr rr)r0r2rEÚ __classcell__rrrYrr‡gs2: ]          y 1   r‡rgc Cszz tj|ddWdStttfyYdSty YdSty<}z|jtjtj hvr7WYd}~dS‚d}~ww)z~Attempt to create the given directory and sub-directories exist. Returns True if successful or if it already exists. T)Úexist_okFN) rLÚmakedirsÚFileNotFoundErrorÚNotADirectoryErrorÚFileExistsErrorÚPermissionErrorrÅrÆÚEROFSÚENOSYS)rgrÉrrrr_œsñ €ùr_Ú file_pathcCs,tjrttjƒt|jdd…ŽS|jdS)zKReturn the cache directory to write .pyc files for the given .py file path.røroÚ __pycache__)r\Úpycache_prefixrryÚparent)rPrrrr^µs r^)r±r²rlr³rkr´r%r&) rOrrkr´rlr³rjrr%rn)rRrr$rr%rÊ)rÓrrjrrDrØr%rÙr­) rrçrÓršrèrér$rêr%r&)rìrír%r9)r$rêr%rö)rìrír%rn)rrr rnr%r9) rrrrrrrrr%r9)rr¸rr9rr9r%r&)r%rn)r1r2r%r3)r7ršr%r8)rgrr%rn)rPrr%r)sr‰r\rrÏÚ collectionsrÚcollections.abcrrrrrÆÚ functoolsr°rFÚimportlib.machineryÚimportlib.utilrFrÄr½rLÚpathlibrr r»r\rErªÚtypingr r Ú_pytest._io.safereprr r rÚ_pytest._versionrÚ_pytest.assertionrÚ_pytest.configrÚ_pytest.fixturesrÚ _pytest.mainrÚ_pytest.pathlibrrÚ _pytest.stashrÚ_pytest.assertion.utilrrºrrrBÚimplementationÚ cache_tagÚ PYTEST_TAGÚPYC_EXTr`rtÚabcÚMetaPathFinderÚLoaderr#rÂrcrbrarÑrõrórrr rr"r#rÇÚInvertÚUSubÚUAddrÚBitOrÚBitXorÚBitAndÚLShiftÚRShiftrÉÚSubÚMultÚDivÚFloorDivr¬ÚEqÚNotEqÚLtÚLtEÚGtÚGtEÚPowÚIsÚIsNotræÚNotInÚMatMultrr5Ú lru_cacherSÚ NodeVisitorr‡r_r^rrrrÚsè                           u   ÿ4 ü     ÿþýüûúùø ÷ ö õ ô óòñðïé   6 9