[Fi5dZddlmZddlZddlmZddlmZddlmZddlm 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)dejDZ#e Gd*d%e#Z$y)-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|dddy#1swYyxYww)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 a/var/www/html/BankruptcyAI-uat/bankruptcy-ai/venv/lib/python3.12/site-packages/_pytest/recwarn.pyrecwarnr!s< d +D i( sA4 A=A.matchr#rcyNr"s r deprecated_callr',sfuncargskwargscyr%r&)r)r*r+s r r'r'2sMPr(cRd}||g|}ttttfg|i|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'6sC4 }t}  6 F IM QW r(expected_warningWarningsCheckercyr%r&)r3r#s r r.r.Xs r(cyr%r&)r3r)r*r+s r r.r.`s r(c,d}|s9|r)djt|}td|dt||dS|d}t |st|dt |dt|d 5||d d i|cd d d S#1swYy xYw) 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 TypeErrorr4callabletype)r3r#r*r+r2argnamesr)s r r.r.is^  yy0HGz56 /ETRRAw~thod4j\ASTU U - > -ab,V, - - -s 5 B  BceZdZdZdddeddffdZededfd 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`. FrrrNcXt|t| dd|_g|_y)NT)recordF)rsuper__init___entered_list)selfr __class__s r rDzWarningsRecorder.__init__s)y! % 46 r(zwarnings.WarningMessagec|jS)zThe list of recorded warnings.rFrGs r listzWarningsRecorder.listszzr(ic |j|S)z Get a recorded warning by index.rJ)rGrMs r __getitem__zWarningsRecorder.__getitem__szz!}r(c,t|jS)z&Iterate through the recorded warnings.)iterrFrKs r __iter__zWarningsRecorder.__iter__sDJJr(c,t|jS)z The number of recorded warnings.)lenrFrKs r __len__zWarningsRecorder.__len__s4::r(clscd}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) enumeraterFcategorypop issubclassAssertionError)rGrVbest_idxrMwr2s r rZzWarningsRecorder.pops #'djj) DAqzzS zz~~a((!**c* !!**djj.B.K.KL   ::>>(+ + w&@ABBr(c"g|jddy)z$Clear the list of recorded warnings.NrJrKs r clearzWarningsRecorder.clears 1 r(c|jrd}td|dt| }|J||_t j d|S)NTz Cannot enter z twicealways)rE RuntimeErrorrC __enter__rFrr)rGr2rFrHs r rdzWarningsRecorder.__enter__sW == $ thf=> >!#    h' r(exc_typeexc_valexc_tbcp|jsd}td|dt| |||d|_y)NTz Cannot exit z without entering firstF)rErcrC__exit__)rGrerfrgr2rHs r rizWarningsRecorder.__exit__sA }} $ dX5LMN N 7F3 r()rN)rr)__name__ __module__ __qualname____doc__boolrDpropertyr rLintrOr rRrUWarningrrZr`rdr BaseExceptionrri __classcell__rHs@r rrs -27T7d7 d45S%> (#<= (/CtG}C3LC& 4 ./-('   r(c eZdZedfdddeeeeeedffdeeee efde ddffd Z d e jde fd Zd eeed eedeeddffd ZxZS)r4NFrr3.r8rrcTt|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) rrCrD isinstancetupler[rqr<r>r3r8)rGr3r8rmsgexcexpected_warning_tuprHs r rDzWarningsChecker.__init__s y! 4(? & .' 5!#w/#C$s)O44 5$4 ($ /J g5 %5#6 C$'7"889 9 4$r(warningc|jJt|j|jxrLt|jduxs3t j |jt|jSr%) r3r[rYrnr8researchstrmessage)rGr|s r matcheszWarningsChecker.matchesse$$000'**D,A,AB t OOt # Wryy#gooBV'WH  r(rerfrgc ht|||d}|!t|trt|trydt ffd } t fdDs"tdjd|dnBt fdDs.tdjd jd |dD]k}j|rtj|j|j|j|j |j"|j$ mD]}t'|jt(ur|jj*s6|jj*d }t|t r`t-d |dt'|j.dy#D]k}j|rtj|j|j|j|j |j"|j$ mD]}t'|jt(ur|jj*s6|jj*d }t|t r`t-d |dt'|j.dwxYw)NTrcXtDcgc]}|jc}dScc}w)N)indent)rr)rBrGs r found_strz+WarningsChecker.__exit__..found_str9s">vFNN>qI I>s'c3^K|]$}t|jj&ywr%)r[rYr3.0r^rGs r z+WarningsChecker.__exit__..=s"Sz!**d.C.CDSs*-z"DID NOT WARN. No warnings of type z" were emitted. Emitted warnings: .c3@K|]}j|ywr%)rrs r rz+WarningsChecker.__exit__..Bs7Qa7sz* matching the regex were emitted. Regex: z Emitted warnings: )rrYfilenamelinenomodulesourcerz$Warning must be str or Warning, got z (type ))rCrirw Exceptionrranyrr3r8rr warn_explicitrrYrrrkrr> UserWarningr*r<rj) rGrerfrgr2rr^ryrHs ` r rizWarningsChecker.__exit__$sy 7F3   7I.'4(  J3 J2 SdSS89N9N8OP**3+a97$7789N9N8OP#/0**3+a9 ||A** ! !"!" xx || xx  &  ?+5yy~~iinnQ'c3' :3'cI[I[H\\]^ ' ||A** ! !"!" xx || xx  &  ?+5yy~~iinnQ'c3' :3'cI[I[H\\]^ sA8F77J1C"J1)rjrkrlrqrrrr rr rnrDrWarningMessagerrrrrirsrts@r r4r4sMT9=%  %W uT']C5G/H HI%U3 #456%  %  %4 x66 4 J4 ./J-(J' J  JJr(r%).)%rmpprintrr~typesrtypingrrrrr r r r r rrrrr_pytest.deprecatedr_pytest.fixturesr_pytest.outcomesrrrr!rr'rqr.catch_warningsrr4r&r(r rs5 -$!! CL  9:    36uS'#,./0   P(36*P3P#P!P P*. 8CH% &69EH s "#D HK14DM5g1C+DDE E#ws|+, -    DM5g1C+DDE 36          IP=-15=-DM5g1C+DDE=- =- E#ws|+, -=- =-  c !" =-@Vx..Vrk&kkr(