
    F-Ph3                       d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddl	Z	ddl
mZ dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZ erddlmZ ddlZddlmZ ddlmZ ddlmZ ddlmZ  ed          Zed/d            Zeddd0d            Zed1d"            Z	 d2d3d%Ze	 d4ddd5d)            Zed6d*            Ze fddd7d,Z G d- dej!                  Z"e G d. d(e"                      Z#dS )8z/Record warnings during test function execution.    )annotations)Callable)	Generator)IteratorpformatN)TracebackType)Any)final)overload)TYPE_CHECKING)TypeVar)Self)check_ispytest)fixture)Exit)failTreturnGenerator[WarningsRecorder]c               #     K   t          d          } | 5  t          j        d           | V  ddd           dS # 1 swxY w Y   dS )zReturn a :class:`WarningsRecorder` instance that records all warnings emitted by test functions.

    See :ref:`warnings` for information on warning categories.
    T	_ispytestdefaultN)WarningsRecorderwarningssimplefilter)wrecs    O/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/_pytest/recwarn.pyrecwarnr    !   s       d+++D	  i(((


                 s   ;??.matchr"   str | re.Pattern[str] | Noner   c                    d S N r!   s    r   deprecated_callr'   -   s	     s    funcCallable[..., T]argsr
   kwargsc                    d S r%   r&   )r)   r+   r,   s      r   r'   r'   3   s    MPSr(   Callable[..., Any] | NoneWarningsRecorder | Anyc                Z    d}| | g|R }t          t          t          t          fg|R i |S )a  Assert 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)warnsDeprecationWarningPendingDeprecationWarningFutureWarning)r)   r+   r,   __tracebackhide__s       r   r'   r'   7   sT    4 }t}}	6FIM  QW  r(   expected_warning)type[Warning] | tuple[type[Warning], ...]WarningsCheckerc                   d S r%   r&   )r6   r"   s     r   r1   r1   Y   s	    
 cr(   c                    d S r%   r&   )r6   r)   r+   r,   s       r   r1   r1   a   s	     	r(   WarningsChecker | Anyc                  d}|sI|r5d                     t          |                    }t          d| d          t          | |d          S |d         }t	          |          s"t          |dt          |           d          t          | d	          5   ||d
d         i |cddd           S # 1 swxY w Y   dS )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 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_exprr   r   z object (type: z) must be callabler      N)joinsorted	TypeErrorr8   callabletype)r6   r"   r+   r,   r5   argnamesr)   s          r   r1   r1   j   sA   ^  - 	yy00H6 6 6 6   /ETRRRRAw~~ 	VtTTd4jjTTTUUU->>> 	- 	-4abb,V,,	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	-s   B55B9<B9c                       e Zd ZdZddd fdZed d
            Zd!dZd"dZd#dZ	e
fd$dZd%dZd& fdZd' fdZ xZS )(r   aF  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`.

    Fr   r   boolr   Nonec                   t          |           t                                          d           d| _        g | _        d S )NT)recordF)r   super__init___entered_list)selfr   	__class__s     r   rK   zWarningsRecorder.__init__   s>    y!!!%%%46


r(   list[warnings.WarningMessage]c                    | j         S )zThe list of recorded warnings.rM   rN   s    r   listzWarningsRecorder.list   s     zr(   iintwarnings.WarningMessagec                    | j         |         S )z Get a recorded warning by index.rR   )rN   rU   s     r   __getitem__zWarningsRecorder.__getitem__   s    z!}r(   !Iterator[warnings.WarningMessage]c                *    t          | j                  S )z&Iterate through the recorded warnings.)iterrM   rS   s    r   __iter__zWarningsRecorder.__iter__   s    DJr(   c                *    t          | j                  S )z The number of recorded warnings.)lenrM   rS   s    r   __len__zWarningsRecorder.__len__   s    4:r(   clstype[Warning]c                d   d}t          | j                  D ]j\  }}|j        |k    r| j                            |          c S t	          |j        |          r)|%t	          |j        | j        |         j                  s|}k|| j                            |          S d}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)	enumeraterM   categorypop
issubclassAssertionError)rN   ra   best_idxrU   wr5   s         r   rf   zWarningsRecorder.pop   s    
  $dj)) 	 	DAqzS  z~~a(((((!*c**  !!*dj.B.KLL ! :>>(+++ AAABBBr(   c                    g | j         dd<   dS )z$Clear the list of recorded warnings.NrR   rS   s    r   clearzWarningsRecorder.clear   s    
111r(   r   c                    | j         rd}t          d| d          t                                                      }|J || _        t          j        d           | S )NTzCannot enter z twicealways)rL   RuntimeErrorrJ   	__enter__rM   r   r   )rN   r5   rM   rO   s      r   rp   zWarningsRecorder.__enter__   sk    = 	? $=t===>>>!!##   
h'''r(   exc_typetype[BaseException] | Noneexc_valBaseException | Noneexc_tbTracebackType | Nonec                    | j         sd}t          d| d          t                                          |||           d| _         d S )NTzCannot exit z without entering firstF)rL   ro   rJ   __exit__)rN   rq   rs   ru   r5   rO   s        r   rx   zWarningsRecorder.__exit__   sY     } 	O $MdMMMNNN7F333 r(   )r   rF   r   rG   )r   rP   )rU   rV   r   rW   )r   rZ   )r   rV   )ra   rb   r   rW   )r   rG   )r   r   rq   rr   rs   rt   ru   rv   r   rG   )__name__
__module____qualname____doc__rK   propertyrT   rY   r]   r`   Warningrf   rl   rp   rx   __classcell__rO   s   @r   r   r      s%       
 
 -2 7 7 7 7 7 7 7 7    X              (/ C C C C C&   	 	 	 	 	 	         r(   c                  @     e Zd Zedfddd fdZddZd fdZ xZS )r8   NFr   r6   r7   r=   r#   r   rF   r   rG   c                  t          |           t                                          d           d}t          |t                    r<|D ]6}t          |t                    st          |t          |          z            7|}nMt          |t                    rt          |t                    r|f}nt          |t          |          z            || _	        || _
        d S )NTr   z/exceptions must be derived from Warning, not %s)r   rJ   rK   
isinstancetuplerg   r   rA   rC   r6   r=   )rN   r6   r=   r   msgexcexpected_warning_tuprO   s          r   rK   zWarningsChecker.__init__  s     	y!!!4(((?&.. 
	:' 5 5!#w// 5#C$s))O4445#3  ($// 	:Jg5
 5
 	: %5#6  C$'7"8"88999 4$r(   warningrW   c                    | j         J t          |j        | j                   oAt          | j        d u p+t          j        | j        t          |j                                      S r%   )	r6   rg   re   rF   r=   researchstrmessage)rN   r   s     r   matcheszWarningsChecker.matches  sc    $000'*D,ABB 
tOt#Wry#goBVBV'W'WH
 H
 	
r(   rq   rr   rs   rt   ru   rv   c                    t                                          |||           d}|,t          |t                    rt          |t                    rd S d fd}	 t           fd D                       s$t          d j         d |             d           nFt           fd	 D                       s+t          d j         d
 j         d |             d            D ]O} 	                    |          s8t          j        |j        |j        |j        |j        |j        |j                   P D ]z}t%          |j                  t&          ur|j        j        s+|j        j        d         }t          |t*                    rSt-          d|dt%          |          j         d          d S #  D ]O} 	                    |          s8t          j        |j        |j        |j        |j        |j        |j                   P D ]z}t%          |j                  t&          ur|j        j        s+|j        j        d         }t          |t*                    rSt-          d|dt%          |          j         d          w xY w)NTr   r   c                 :    t          d  D             d          S )Nc                    g | ]	}|j         
S r&   )r   ).0rI   s     r   
<listcomp>z?WarningsChecker.__exit__.<locals>.found_str.<locals>.<listcomp>9  s    >>>vFN>>>r(      )indentr   rS   s   r   	found_strz+WarningsChecker.__exit__.<locals>.found_str8  s%    >>>>>qIIIIr(   c              3  L   K   | ]}t          |j        j                  V  d S r%   )rg   re   r6   r   rj   rN   s     r   	<genexpr>z+WarningsChecker.__exit__.<locals>.<genexpr><  s2      SSz!*d.CDDSSSSSSr(   z"DID NOT WARN. No warnings of type z" were emitted.
 Emitted warnings: .c              3  B   K   | ]}                     |          V  d S r%   )r   r   s     r   r   z+WarningsChecker.__exit__.<locals>.<genexpr>A  s-      77Qa777777r(   z* matching the regex were emitted.
 Regex: z
 Emitted warnings: )r   re   filenamelinenomodulesourcer   z$Warning must be str or Warning, got z (type ))r   r   )rJ   rx   r   	Exceptionr   anyr   r6   r=   r   r   warn_explicitr   re   r   r   r{   r   rC   UserWarningr+   r   rA   rz   )	rN   rq   rs   ru   r5   r   rj   r   rO   s	   `       r   rx   zWarningsChecker.__exit__#  sI    	7F333  7I..  '4(( 
 F	J 	J 	J 	J 	J 	J2	SSSSdSSSSS 
99N 9 9*3)++9 9 9    7777$77777 99N 9 9#9 9*3)++9 9 9    	 	||A * !	!"!" x | x   "   	??+55 y~ inQ'c3''   ^3^^cI[^^^   '  	 	||A * !	!"!" x | x   "   	??+55 y~ inQ'c3''   ^3^^cI[^^^  s   BF3 3CJ)r6   r7   r=   r#   r   rF   r   rG   )r   rW   r   rF   ry   )rz   r{   r|   r   rK   r   rx   r   r   s   @r   r8   r8     s         GN37%
  % % % % % % % %4
 
 
 
J J J J J J J J J Jr(   )r   r   )r"   r#   r   r   )r)   r*   r+   r
   r,   r
   r   r   r%   )r)   r.   r+   r
   r,   r
   r   r/   ).)r6   r7   r"   r#   r   r8   )
r6   r7   r)   r*   r+   r
   r,   r
   r   r   )
r6   r7   r+   r
   r"   r#   r,   r
   r   r;   )$r}   
__future__r   collections.abcr   r   r   pprintr   r   typesr	   typingr
   r   r   r   r   typing_extensionsr   r   _pytest.deprecatedr   _pytest.fixturesr   _pytest.outcomesr   r   r   r    r'   r1   r   catch_warningsr   r8   r&   r(   r   <module>r      s   5 5 " " " " " " $ $ $ $ $ $ % % % % % % $ $ $ $ $ $       				                                            '&&&&&&  - - - - - - $ $ $ $ $ $ ! ! ! ! ! ! ! ! ! ! ! ! GCLL 	   	 
-0     

 
 P P P 
 P '+    D 
BE +.     
 
   
 CJ=- +/=- =- =- =- =- =-@T T T T Tx. T T Tn k k k k k& k k k k kr(   