yIf5dZddlmZddlZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZddlmZddlmZddlmZddlmZddlZddlmZddlmZddlmZddlmZedZede dfdZeddde eeeefddfdZededefd ed!edefd"Z d+de edefd ed!ededeffd#Ze d,ddd$eee eee dffde eeeefdd%fd&Z!ed$eee eee dffdedefd ed!edef d'Z!e fddd$eee eee dffd ede eeeefd!eded%eff d(Z!Gd)dej"Z#e Gd*d%e#Z$dS)-z/Record warnings during test function execution.pformatN) TracebackType)Any)Callable)final) Generator)Iterator)List)Optional)overload)Pattern)Tuple)Type)TypeVar)Union)check_ispytest)fixture)Exit)failTreturn)WarningsRecorderNNc#Ktd}|5tjd|VddddS#1swxYwYdS)zReturn a :class:`WarningsRecorder` instance that records all warnings emitted by test functions. See https://docs.pytest.org/en/latest/how-to/capture-warnings.html for information on warning categories. T _ispytestdefaultN)rwarnings simplefilter)wrecs C/var/www/piapp/venv/lib/python3.11/site-packages/_pytest/recwarn.pyrecwarnr"s d + + +D i((( s ;??.matchr$rcdSNr#s r!deprecated_callr(,s funcargskwargscdSr&r')r*r+r,s r!r(r(2sMPSr)cZd}||g|R}ttttfg|Ri|S)aAssert 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 It can also be used by passing a function and ``*args`` and ``**kwargs``, in which case it will ensure calling ``func(*args, **kwargs)`` produces one of the warnings types above. The return value is the return value of the function. In the context manager form you may use the keyword argument ``match`` to assert that the warning matches a text or regex. The context manager produces a list of :class:`warnings.WarningMessage` objects, one for each warning raised. T)warnsDeprecationWarningPendingDeprecationWarning FutureWarning)r*r+r,__tracebackhide__s r!r(r(6sT4 }t}}  6 F IM   QW  r)expected_warningWarningsCheckercdSr&r')r4r$s r!r/r/Xs r)cdSr&r')r4r*r+r,s r!r/r/`s r)cd}|sI|r5dt|}td|dt||dS|d}t |s"t|dt |dt|d 5||d d i|cd d d S#1swxYwYd S) aAssert 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 can be used as a context manager:: >>> import pytest >>> with pytest.warns(RuntimeWarning): ... warnings.warn("my warning", RuntimeWarning) In the context manager form you may use the keyword argument ``match`` 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: DID NOT WARN. No warnings of type ...UserWarning... were emitted... **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. Tz, z5Unexpected keyword arguments passed to pytest.warns: z" Use context-manager form instead?) match_exprrrz object (type: z) must be callablerN)joinsorted TypeErrorr5callabletype)r4r$r+r,r3argnamesr*s r!r/r/isA^  -  yy00H6666 /ETRRRRAw~~ VtTTd4jjTTTUU U - > > > - -4abb,V,, - - - - - - - - - - - - - - - - - -sB55B9<B9ceZdZdZdddeddffdZededfd Zd e ddfd Z de dfd Z de fd Z efdeeddfdZddZdfd Zdeeedeedeeddffd 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`. FrrrNct|tdd|_g|_dS)NT)recordF)rsuper__init___entered_list)selfr __class__s r!rEzWarningsRecorder.__init__s>y!!! %%% 46 r)zwarnings.WarningMessagec|jS)zThe list of recorded warnings.rGrHs r!listzWarningsRecorder.lists zr)ic|j|S)z Get a recorded warning by index.rK)rHrNs r! __getitem__zWarningsRecorder.__getitem__sz!}r)c*t|jS)z&Iterate through the recorded warnings.)iterrGrLs r!__iter__zWarningsRecorder.__iter__sDJr)c*t|jS)z The number of recorded warnings.)lenrGrLs r!__len__zWarningsRecorder.__len__s4:r)clscdd}t|jD]j\}}|j|kr|j|cSt |j|r)|%t |j|j|js|}k||j|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) enumeraterGcategorypop issubclassAssertionError)rHrWbest_idxrNwr3s r!r[zWarningsRecorder.pops #'dj))  DAqzS  z~~a(((((!*c**  !!*dj.B.KLL!  :>>(++ + AAABBBr)cg|jdd<dS)z$Clear the list of recorded warnings.NrKrLs r!clearzWarningsRecorder.clears 111 r)c|jrd}td|dt}|J||_t jd|S)NTz Cannot enter z twicealways)rF RuntimeErrorrD __enter__rGrr)rHr3rGrIs r!rezWarningsRecorder.__enter__sk = ? $ =t===>> >!!##    h''' r)exc_typeexc_valexc_tbc|jsd}td|dt|||d|_dS)NTz Cannot exit z without entering firstF)rFrdrD__exit__)rHrfrgrhr3rIs r!rjzWarningsRecorder.__exit__sY } O $ MdMMMNN N 7F333 r))rN)rr)__name__ __module__ __qualname____doc__boolrEpropertyr rMintrPr rSrVWarningrr[rarer BaseExceptionrrj __classcell__rIs@r!rrs  -2777T7d777777 d45XS%> (#<=    (/CCtG}C3LCCCC&      4 ./-('   r)c eZdZedfdddeeeeeedffdeeee efde ddffd Z d e j de fd Zd eeed eedeeddffd ZxZS)r5NFrr4.r9rrct|tdd}t|tr<|D]6}t |t st|t|z7|}nMt|trt |t r|f}nt|t|z||_ ||_ dS)NTrz/exceptions must be derived from Warning, not %s) rrDrE isinstancetupler\rrr=r?r4r9)rHr4r9rmsgexcexpected_warning_tuprIs r!rEzWarningsChecker.__init__s y!!! 4(((? & . . :' 5 5!#w//5#C$s))O4445#3 ($ / / :J g5 5  :%5#6 C$'7"8"8899 9 4$r)warningc|jJt|j|joAt|jdup+t j|jt|jSr&) r4r\rZror9researchstrmessage)rHr}s r!matcheszWarningsChecker.matchessc$000'*D,ABB t Ot # Wry#goBVBV'W'WH H  r)rfrgrhc t|||d}|,t|trt|trdSdt ffd } t fdDs$tdjd|dnFt fdDs+tdjd j d |dD]O} |s8tj |j |j|j|j|j|j PD]z}t'|j t(ur|j js+|j jd }t|t rSt-d |dt'|jddS#D]O} |s8tj |j |j|j|j|j|j PD]z}t'|j t(ur|j js+|j jd }t|t rSt-d |dt'|jdwxYw)NTrc:tdDdS)Ncg|] }|j Sr')r).0rCs r! z?WarningsChecker.__exit__..found_str..:s>>>vFN>>>r))indentrrLsr! found_strz+WarningsChecker.__exit__..found_str9s%>>>>>qIII Ir)c3LK|]}t|jjVdSr&)r\rZr4rr_rHs r! z+WarningsChecker.__exit__..=s2SSz!*d.CDDSSSSSSr)z"DID NOT WARN. No warnings of type z" were emitted. Emitted warnings: .c3BK|]}|VdSr&)rrs r!rz+WarningsChecker.__exit__..Bs-77Qa777777r)z* matching the regex were emitted. Regex: z Emitted warnings: )rrZfilenamelinenomodulesourcerz$Warning must be str or Warning, got z (type ))rDrjrx Exceptionrranyrr4r9rr warn_explicitrrZrrrlrr? UserWarningr+r=rk) rHrfrgrhr3rr_rzrIs ` r!rjzWarningsChecker.__exit__$sQ 7F333   7I.. '4((  F J3 J J J J J J2 SSSSdSSSSS 99N99*3)++9997777$77777 99N99#99*3)++999  ||A* ! !"!" x | x "   ??+55y~inQ'c3'' ^3^^cI[^^^  '  ||A* ! !"!" x | x "   ??+55y~inQ'c3'' ^3^^cI[^^^ s$BF::CJ )rkrlrmrrrrrr rrrorErWarningMessagerrsrrjrtrus@r!r5r5s;MT9=%  %%%W uT']C5G/H HI%U3 #456%  %  %%%%%%4 x6 4    J4 ./J-(J' J  JJJJJJJJJJr)r&).)%rnpprintrrtypesrtypingrrrr r r r r rrrrrr_pytest.deprecatedr_pytest.fixturesr_pytest.outcomesrrrr"rr(rrr/catch_warningsrr5r'r)r!rs55 ------$$$$$$!!!!!!!!!!!! GCLL  9:      36uS'#,./0   P(36*P3P#P!PPP P*. 8CH% &69EH s "#D HK14DM5g1C+DDE E#ws|+, -    DM5g1C+DDE 36            IP=-15=-=-=-DM5g1C+DDE=- =- E#ws|+, -=- =-  c !" =-=-=-=-@VVVVVx.VVVrkkkkk&kkkkkr)