jj36dZddlmZddlmZddlmZddlmZddlmZddl Z ddl m Z dd l m Z dd l mZdd l mZdd l mZdd l mZerddlmZddlmZedZddlZddlmZddlmZddlmZddlmZedZed#dZedd d$dZ ed%dZ d& d'dZ e d(dd d)dZ!e d*dZ!e"df d+d Z!Gd!dejFZ$eGd"de$Z%y),z/Record warnings during test function execution.) annotations)Callable) Generator)Iterator)pformatN) TracebackType)Any)final)overload) TYPE_CHECKING)TypeVar) ParamSpec)SelfP)check_ispytest)fixture)Exit)failTc#Ktd}|5tjd|dddy#1swYyxYww)zReturn a :class:`WarningsRecorder` instance that records all warnings emitted by test functions. See :ref:`warnings` for information on warning categories. T _ispytestdefaultN)WarningsRecorderwarnings simplefilter)wrecs Q/opt/eval-harness/bench_task/venv/lib/python3.12/site-packages/_pytest/recwarn.pyrecwarnr$s< d +D i( sA4 A=A.matchrcyNr s rdeprecated_callr%0scyr#r$)funcargskwargss rr%r%6sSVr&cd}tttf}|t|g|i|St|5||i|cdddS#1swYyxYw)aRAssert that code produces a ``DeprecationWarning`` or ``PendingDeprecationWarning`` or ``FutureWarning``. This function can be used as a context manager:: >>> import warnings >>> def api_call_v2(): ... warnings.warn('use v3 of this api', DeprecationWarning) ... return 200 >>> import pytest >>> with pytest.deprecated_call(): ... assert api_call_v2() == 200 >>> with pytest.deprecated_call(match="^use v3 of this api$") as warning_messages: ... assert api_call_v2() == 200 You may use the keyword argument ``match`` to assert that the warning matches a text or regex. The return value is a list of :class:`warnings.WarningMessage` objects, one for each warning emitted (regardless of whether it is an ``expected_warning`` or not). TN)DeprecationWarningPendingDeprecationWarning FutureWarningwarns)r(r)r*__tracebackhide__ dep_warningss rr%r%:s[2&(A=QL |\3D3F33 | %T$V$%%%s AA WarningsCheckercyr#r$)expected_warningr!s rr/r/\s r&cyr#r$)r4r(r)r*s rr/r/ds r&cDd}|M|sK|jdd}|r)djt|}td|dt ||dSt |st|dt |d t |d 5||i|cdddS#1swYyxYw) a%Assert that code raises a particular class of warning. Specifically, the parameter ``expected_warning`` can be a warning class or tuple of warning classes, and the code inside the ``with`` block must issue at least one warning of that class or classes. This helper produces a list of :class:`warnings.WarningMessage` objects, one for each warning emitted (regardless of whether it is an ``expected_warning`` or not). Since pytest 8.0, unmatched warnings are also re-emitted when the context closes. This function should be used as a context manager:: >>> import pytest >>> with pytest.warns(RuntimeWarning): ... warnings.warn("my warning", RuntimeWarning) The ``match`` keyword argument can be used to assert that the warning matches a text or regex:: >>> with pytest.warns(UserWarning, match='must be 0 or None'): ... warnings.warn("value must be 0 or None", UserWarning) >>> with pytest.warns(UserWarning, match=r'must be \d+$'): ... warnings.warn("value must be 42", UserWarning) >>> with pytest.warns(UserWarning): # catch re-emitted warning ... with pytest.warns(UserWarning, match=r'must be \d+$'): ... warnings.warn("this is not here", UserWarning) Traceback (most recent call last): ... Failed: Regex pattern did not match any of the 1 warnings emitted. Regex: ... Emitted warnings: ...UserWarning... **Using with** ``pytest.mark.parametrize`` When using :ref:`pytest.mark.parametrize ref` it is possible to parametrize tests such that some runs raise a warning and others do not. This could be achieved in the same way as with exceptions, see :ref:`parametrizing_conditional_raising` for an example. TNr!z, z5Unexpected keyword arguments passed to pytest.warns: z" Use context-manager form instead?) match_exprrz object (type: z) must be callabler)popjoinsorted TypeErrorr2callabletype)r4r(r)r*r0r!argnamess rr/r/msb |D.4jj$.G yy0HGz56 /ETRR~thod4j\ASTU U - > )(( ) ) )s BBceZdZdZddd fdZeddZddZddZddZ e fdd Z dd Z dfd Z dfd ZxZS)raFA context manager to record raised warnings. Each recorded warning is an instance of :class:`warnings.WarningMessage`. Adapted from `warnings.catch_warnings`. .. note:: ``DeprecationWarning`` and ``PendingDeprecationWarning`` are treated differently; see :ref:`ensuring_function_triggers`. FrcXt|t| dd|_g|_y)NT)recordF)rsuper__init___entered_list)selfr __class__s rrCzWarningsRecorder.__init__s)y! % 46 r&c|jS)zThe list of recorded warnings.rErFs rlistzWarningsRecorder.listszzr&c |j|S)z Get a recorded warning by index.rI)rFis r __getitem__zWarningsRecorder.__getitem__szz!}r&c,t|jS)z&Iterate through the recorded warnings.)iterrErJs r__iter__zWarningsRecorder.__iter__sDJJr&c,t|jS)z The number of recorded warnings.)lenrErJs r__len__zWarningsRecorder.__len__s4::r&cd}t|jD]z\}}|j|k(r|jj|cSt |j|sI|.t |j|j|jry|}|||jj|Sd}t |d)zPop the first recorded warning which is an instance of ``cls``, but not an instance of a child class of any other match. Raises ``AssertionError`` if there is no match. NTz not found in warning list) enumeraterEcategoryr8 issubclassAssertionError)rFclsbest_idxrMwr0s rr8zWarningsRecorder.pops $djj) DAqzzS zz~~a((!**c* !!**djj.B.K.KL   ::>>(+ + w&@ABBr&c"g|jddy)z$Clear the list of recorded warnings.NrIrJs rclearzWarningsRecorder.clears 1 r&c|jrd}td|dt| }|J||_t j d|S)NTz Cannot enter z twicealways)rD RuntimeErrorrB __enter__rErr)rFr0rErGs rrbzWarningsRecorder.__enter__sW == $ thf=> >!#    h' r&cp|jsd}td|dt| |||d|_y)NTz Cannot exit z without entering firstF)rDrarB__exit__)rFexc_typeexc_valexc_tbr0rGs rrdzWarningsRecorder.__exit__sA }} $ dX5LMN N 7F3 r&)rboolreturnNone)rizlist[warnings.WarningMessage])rMintriwarnings.WarningMessage)riz!Iterator[warnings.WarningMessage])rirk)rZz type[Warning]rirl)rirj)rirreztype[BaseException] | NonerfzBaseException | NonergzTracebackType | Nonerirj)__name__ __module__ __qualname____doc__rCpropertyrKrNrQrTWarningr8r^rbrd __classcell__rGs@rrrsz -27  (/C& ,&%   r&c^eZdZedfdd dfdZddZ d fd ZxZS) r2NFrcTt|t| dd}t|tr1|D])}t |t rt|t|z|}n;t|trt |t r|f}nt|t|z||_ ||_ y)NTrz/exceptions must be derived from Warning, not %s) rrBrC isinstancetuplerXrsr;r=r4r7)rFr4r7rmsgexcexpected_warning_tuprGs rrCzWarningsChecker.__init__ s y! 4(? & .' 5!#w/#C$s)O44 5$4 ($ /J g5 %5#6 C$'7"889 9 4$r&c|jJt|j|jxrLt|jduxs3t j |jt|jSr#) r4rXrWrhr7researchstrmessage)rFwarnings rmatcheszWarningsChecker.matches$se$$000'**D,A,AB t OOt # Wryy#gooBV'WH  r&c t |||d}|!t|trt|trydfd } t fdDs"t djd|dnut fdDsad}tjtrt fd Drd }t d td jd |d|D]k}j|rtj|j|j|j |j"|j$|j&mD]}t)|jt*ur|jj,s6|jj,d}t|tr`t/d|dt)|j0dy#D]k}j|rtj|j|j|j |j"|j$|j&mD]}t)|jt*ur|jj,s6|jj,d}t|tr`t/d|dt)|j0dwxYw)NTcXtDcgc]}|jc}dScc}w)N)indent)rr)rArFs r found_strz+WarningsChecker.__exit__..found_str?s">vFNN>qI I>s'c3^K|]$}t|jj&ywr#)rXrWr4.0r\rFs r z+WarningsChecker.__exit__..Cs"Sz!**d.C.CDSs*-z"DID NOT WARN. No warnings of type z" were emitted. Emitted warnings: .c3@K|]}j|ywr#)rrs rrz+WarningsChecker.__exit__..Hs7Qa7sc3K|]F}t|jjr$jt |j k(Hywr#)rXrWr4r7rrrs rrz+WarningsChecker.__exit__..Js><!!**d.C.CDOOs199~5<sA Az* Did you mean to `re.escape()` the regex?z'Regex pattern did not match any of the z warnings emitted. Regex: z Emitted warnings: )rrWfilenamelinenomodulesourcerz$Warning must be str or Warning, got z (type ))rir)rBrdrx Exceptionranyrr4r7rrSrr warn_explicitrrWrrrorr= UserWarningr)r;rn) rFrerfrgr0r escape_hintr\rzrGs ` rrdzWarningsChecker.__exit__*s 7F3   7I.'4(  J9 SdSS89N9N8OP**3+a97$77 doos3<!<9 #PK=c$i[I#12**3+a }F ||A** ! !"!" xx || xx  &  ?+5yy~~iinnQ'c3' :3'cI[I[H\\]^ ' ||A** ! !"!" xx || xx  &  ?+5yy~~iinnQ'c3' :3'cI[I[H\\]^ sB+G$$Krs5"$%$  +&#A-$!! CL   -0*   V V'+% #%36%BE%%D BE+.? (    ?          CJ)-?)??) &?) ?) ?)  ?)DVx..Vrr&rrr&