ޠj36<SrSSKJr SSKJr SSKJr SSKJr SSKJr SSK r SSK J r SS K J r SS K Jr SS K Jr SS K Jr SS K Jr \(aSSKJr SSKJr \"S5rSSKrSSKJr SSKJr SSKJr SSKJr \"S5r\S#Sj5r\SS.S$Sjj5r \S%Sj5r S&S'Sjjr \S(SS.S)Sjjj5r!\S*Sj5r!\"S4S+S jjr!"S!S\RF5r$\"S"S\$55r%g),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## [SS9nU [R"S5 Uv SSS5 g!,(df  g=f7f)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 I/var/www/html/gaurav/venv/lib/python3.13/site-packages/_pytest/recwarn.pyrecwarnr$s0 d +D i(  s A2 A AA.matchrcgNr s rdeprecated_callr%0scgr#r$)funcargskwargss rr%r%6sSVr&cSn[[[4nUc[U/UQ70UD6$[U5 U"U0UD6sSSS5 $!,(df  g=f)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 >>> 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%:sR2&(A=QL |\3D3F33 | T$V$   s A AWarningsCheckercgr#r$)expected_warningr!s rr/r/\s r&cgr#r$)r4r(r)r*s rr/r/ds r&cbSnUcSU(dLURSS5nU(a)SR[U55n[SUS35e[ XSS9$[ U5(d[U<S[ U5S 35e[ USS 9 U"U0UD6sSSS5 $!,(df  g=f) 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 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 /TRR~~thod4j\ASTU U - >((? > >s B  B.c^\rSrSrSrSS.SU4Sjjjr\SSj5rSSjrSSjr SS jr \ 4SS jjr SS jr SU4S jjrSU4S jjrSrU=r$)ra.A 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`. FrcR>[U5 [TU] SS9 SUl/Ulg)NT)recordF)rsuper__init___entered_list)selfr __class__s rrDWarningsRecorder.__init__s)y! % 46 r&cUR$)zThe list of recorded warnings.rFrGs rlistWarningsRecorder.listszzr&c URU$)z Get a recorded warning by index.rK)rGis r __getitem__WarningsRecorder.__getitem__szz!}r&c,[UR5$)z&Iterate through the recorded warnings.)iterrFrLs r__iter__WarningsRecorder.__iter__sDJJr&c,[UR5$)z The number of recorded warnings.)lenrFrLs r__len__WarningsRecorder.__len__s4::r&cSn[UR5Hup4URU:XaURRU5s $[ URU5(dMOUb4[ URURUR5(aMUnM UbURRU5$Sn[ U<S35e)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) enumeraterFcategoryr8 issubclassAssertionError)rGclsbest_idxrPwr0s rr8WarningsRecorder.pops $djj)DAzzS zz~~a((!**c** !!**djj.B.K.KLL*  ::>>(+ + w&@ABBr&c"/URSS&g)z$Clear the list of recorded warnings.NrKrLs rclearWarningsRecorder.clears 1 r&c>UR(aSn[SU<S35e[TU] 5nUceX l[ R "S5 U$)NTz Cannot enter z twicealways)rE RuntimeErrorrC __enter__rFrr)rGr0rFrHs rrjWarningsRecorder.__enter__sU == $ thf=> >!#    h' r&cz>UR(dSn[SU<S35e[TU] XU5 SUlg)NTz Cannot exit z without entering firstF)rErirC__exit__)rGexc_typeexc_valexc_tbr0rHs rrmWarningsRecorder.__exit__s? }} $ dX5LMN N F3 r&)rErF)rboolreturnNone)rszlist[warnings.WarningMessage])rPintrswarnings.WarningMessage)rsz!Iterator[warnings.WarningMessage])rsru)r`z type[Warning]rsrv)rsrt)rsrrnztype[BaseException] | NonerozBaseException | NonerpzTracebackType | Nonersrt)__name__ __module__ __qualname____firstlineno____doc__rDpropertyrMrQrUrYWarningr8rerjrm__static_attributes__ __classcell__rHs@rrrs -277  (/C& ,&%   r&ct^\rSrSr\S4SS.S U4SjjjjrS SjrS U4SjjrSrU=r $) r2iNFrcv>[U5 [TU] SS9 Sn[U[5(a8UH/n[ U[ 5(aM[U[U5-5e UnOE[U[5(a[ U[ 5(aU4nO[U[U5-5eX`l X l g)NTrz/exceptions must be derived from Warning, not %s) rrCrD isinstancetupler^r~r;r=r4r7)rGr4r7rmsgexcexpected_warning_tuprHs rrDWarningsChecker.__init__ s y! 4(? & . .'!#w//#C$s)O44($4 ($ / /J g5 5 %5#6 C$'7"889 9 4$r&cURce[URUR5=(aR [URSL=(d4 [ R "UR[UR555$r#) r4r^r]rrr7researchstrmessage)rGwarnings rmatchesWarningsChecker.matches$se$$000'**D,A,AB t OOt # Wryy#gooBV'WH  r&c b>^[T T]XU5 SnUb+[U[5(a[U[5(agSU4Sjjn[ U4SjT55(d"[ STRSU"5S35 O[ U4SjT55(dmSn[TR[5(a[ U4S jT55(aS n[ S [T5S TR<S U"5SU35 THpnTRU5(aM[R"URURUR UR"UR$UR&S9 Mr THn[)UR5[*LaM!URR,(dM>URR,Sn[U[5(aMn[/SU<S[)U5R0S35e g!THpnTRU5(aM[R"URURUR UR"UR$UR&S9 Mr THn[)UR5[*LaM!URR,(dM>URR,Sn[U[5(aMn[/SU<S[)U5R0S35e f=f)NTcT>[TVs/sHoRPM snSS9$s snf)N)indent)rr)rBrGs r found_str+WarningsChecker.__exit__..found_str?s$>vNN>qI I>s%c3b># UH%n[URTR5v M' g7fr#)r^r]r4.0rbrGs r +WarningsChecker.__exit__..Cs%Sdz!**d.C.CDDds,/z"DID NOT WARN. No warnings of type z" were emitted. Emitted warnings: .c3D># UHnTRU5v M g7fr#)rrs rrrHs7$Qa$s c3># UHNn[URTR5(dM*TR[ UR 5:Hv MP g7fr#)r^r]r4r7rrrs rrrJs?<!!!**d.C.CD6DOOs199~5!s (A)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: )rr]filenamelinenomodulesourcerz$Warning must be str or Warning, got z (type ))rsr)rCrmr Exceptionranyrr4r7rrXrr warn_explicitrr]rrryrr= UserWarningr)r;rx) rGrnrorpr0r escape_hintrbrrHs ` rrmWarningsChecker.__exit__*s F3   7I..'4((  J9 SdSSS89N9N8OP**3+a97$777 doos33<!<99 #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\\]^s CHL.rs5"$%$  +&#A-$!! CL   -0*   V V'+% #%36%BE%%D BE+.? (    ?          CJ)-?)??) &?) ?) ?)  ?)DVx..Vrr&rrr&