Файловый менеджер - Редактировать - /usr/lib/rads/venv/lib/python3.13/site-packages/_pytest/__pycache__/raises.cpython-313.pyc
Ðазад
� � �i$� � �& � S SK Jr S SKJr S SKJr S SKrS SKJr S SKrS SKJ r S SK J r S SK J r S S K J r S S K Jr S S K Jr S S K Jr S S K Jr S SK Jr S SK Jr S SKrS SKJr S SKJr S SKJr S SKJ r \( a< S SK J r S SK J r S SK r S SK!J"r" S SK!J#r# S SK!J$r$ \"" S5 r%\$" S\&\&SS 9r'\$" S \&\&S 9r(OS SK J$r$ \$" S\&SS 9r'\$" S \&SS 9r)\$" S!\&S"9r*\$" S#\&S"9r+\$" S$\,S"9r-\$" S%\,S"9r.\R^ S&: a S S'K0J1r1 S S(K0J2r2 \Rf " S)5 Rh r5\S*S*S+. SDS, jj5 r6\S*S-. SES. jj5 r6\SFS/ j5 r6\ SGS0 j5 r6 SH SIS1 jjr6\RX \6l, SJS2 jr7SKS3 jr8SLS4 jr9 SMS5 jr: SNS6 jr;SOS7 jr<SLS8 jr= " S9 S:\\\) 5 r>\ " S; S<\>\' 5 5 r?\ " S= S>\>\1\) 5 5 r@\ " S? S@5 5 rA " SA SB5 rBSHSPSC jjrCg)Q� )� annotations)�ABC)�abstractmethodN)�Pattern)�indent)�Any)�cast)�final)�Generic)�get_args)� get_origin)�Literal)�overload)� TYPE_CHECKING)� ExceptionInfo)�stringify_exception)�fail)� PytestWarning)�Callable)�Sequence)� ParamSpec)� TypeGuard)�TypeVar�P�BaseExcT_co_defaultT)�bound�default� covariant�E)r r )r r � BaseExcT_co� BaseExcT_1)r � BaseExcT_2�ExcT_1�ExcT_2)� � )�BaseExceptionGroup)�ExceptionGroup� .��match�checkc � � g �N� )�expected_exceptionr+ r, s �A/usr/lib/rads/venv/lib/python3.13/site-packages/_pytest/raises.py�raisesr2 I s � � � �r, c � � g r. r/ r* s r1 r2 r2 R s � � #r3 c � � g r. r/ r4 s r1 r2 r2 [ s � �SVr3 c � � g r. r/ )r0 �func�args�kwargss r1 r2 r2 _ s � � r3 c �� � SnU( d^ [ U5 1 Sk- ( a/ SnUSR [ U5 5 - nUS- n[ U5 eU c [ S 0 UD6$ [ U 40 UD6$ U ( d [ SU < S35 eUS n[ U5 ( d [ U< S [ U5 S 35 e[ U 5 nU" US S 0 UD6 SSS5 WA$ ! , ( d f N= f! Af = f)a' Assert that a code block/function call raises an exception type, or one of its subclasses. :param expected_exception: The expected exception type, or a tuple if one of multiple possible exception types are expected. Note that subclasses of the passed exceptions will also match. This is not a required parameter, you may opt to only use ``match`` and/or ``check`` for verifying the raised exception. :kwparam str | re.Pattern[str] | None match: If specified, a string containing a regular expression, or a regular expression object, that is tested against the string representation of the exception and its :pep:`678` `__notes__` using :func:`re.search`. To match a literal string that may contain :ref:`special characters <re-syntax>`, the pattern can first be escaped with :func:`re.escape`. (This is only used when ``pytest.raises`` is used as a context manager, and passed through to the function otherwise. When using ``pytest.raises`` as a function, you can use: ``pytest.raises(Exc, func, match="passed on").match("my pattern")``.) :kwparam Callable[[BaseException], bool] check: .. versionadded:: 8.4 If specified, a callable that will be called with the exception as a parameter after checking the type and the match regex if specified. If it returns ``True`` it will be considered a match, if not it will be considered a failed match. Use ``pytest.raises`` as a context manager, which will capture the exception of the given type, or any of its subclasses:: >>> import pytest >>> with pytest.raises(ZeroDivisionError): ... 1/0 If the code block does not raise the expected exception (:class:`ZeroDivisionError` in the example above), or no exception at all, the check will fail instead. You can also use the keyword argument ``match`` to assert that the exception matches a text or regex:: >>> with pytest.raises(ValueError, match='must be 0 or None'): ... raise ValueError("value must be 0 or None") >>> with pytest.raises(ValueError, match=r'must be \d+$'): ... raise ValueError("value must be 42") The ``match`` argument searches the formatted exception string, which includes any `PEP-678 <https://peps.python.org/pep-0678/>`__ ``__notes__``: >>> with pytest.raises(ValueError, match=r"had a note added"): # doctest: +SKIP ... e = ValueError("value must be 42") ... e.add_note("had a note added") ... raise e The ``check`` argument, if provided, must return True when passed the raised exception for the match to be successful, otherwise an :exc:`AssertionError` is raised. >>> import errno >>> with pytest.raises(OSError, check=lambda e: e.errno == errno.EACCES): ... raise OSError(errno.EACCES, "no permission to view") The context manager produces an :class:`ExceptionInfo` object which can be used to inspect the details of the captured exception:: >>> with pytest.raises(ValueError) as exc_info: ... raise ValueError("value must be 42") >>> assert exc_info.type is ValueError >>> assert exc_info.value.args[0] == "value must be 42" .. warning:: Given that ``pytest.raises`` matches subclasses, be wary of using it to match :class:`Exception` like this:: # Careful, this will catch ANY exception raised. with pytest.raises(Exception): some_function() Because :class:`Exception` is the base class of almost all exceptions, it is easy for this to hide real bugs, where the user wrote this expecting a specific exception, but some other exception is being raised due to a bug introduced during a refactoring. Avoid using ``pytest.raises`` to catch :class:`Exception` unless certain that you really want to catch **any** exception raised. .. note:: When using ``pytest.raises`` as a context manager, it's worthwhile to note that normal context manager rules apply and that the exception raised *must* be the final line in the scope of the context manager. Lines of code after that, within the scope of the context manager will not be executed. For example:: >>> value = 15 >>> with pytest.raises(ValueError) as exc_info: ... if value > 10: ... raise ValueError("value must be <= 10") ... assert exc_info.type is ValueError # This will not execute. Instead, the following approach must be taken (note the difference in scope):: >>> with pytest.raises(ValueError) as exc_info: ... if value > 10: ... raise ValueError("value must be <= 10") ... >>> assert exc_info.type is ValueError **Expecting exception groups** When expecting exceptions wrapped in :exc:`BaseExceptionGroup` or :exc:`ExceptionGroup`, you should instead use :class:`pytest.RaisesGroup`. **Using with** ``pytest.mark.parametrize`` When using :ref:`pytest.mark.parametrize ref` it is possible to parametrize tests such that some runs raise an exception and others do not. See :ref:`parametrizing_conditional_raising` for an example. .. seealso:: :ref:`assertraises` for more examples and detailed discussion. **Legacy form** It is possible to specify a callable by passing a to-be-called lambda:: >>> raises(ZeroDivisionError, lambda: 1/0) <ExceptionInfo ...> or you can specify an arbitrary callable with arguments:: >>> def f(x): return 1/x ... >>> raises(ZeroDivisionError, f, 0) <ExceptionInfo ...> >>> raises(ZeroDivisionError, f, x=0) <ExceptionInfo ...> The form above is fully supported but discouraged for new code because the context manager form is regarded as more readable and less error-prone. .. note:: Similar to caught exception objects in Python, explicitly clearing local references to returned ``ExceptionInfo`` objects can help the Python interpreter speed up its garbage collection. Clearing those references breaks a reference cycle (``ExceptionInfo`` --> caught exception --> frame stack raising the exception --> current frame stack --> local variables --> ``ExceptionInfo``) which makes Python keep all objects referenced from that cycle (including all local variables in the current frame) alive until the next cyclic garbage collection run. More detailed information can be found in the official Python documentation for :ref:`the try statement <python:try>`. T> r, r+ r0 z6Unexpected keyword arguments passed to pytest.raises: �, z" Use context-manager form instead?NzCExpected an exception type or a tuple of exception types, but got `z�`. Raising exceptions is already understood as failing the test, so you don't need any special code to say 'this should never raise an exception'.r z object (type: z) must be callable� r/ )�set�join�sorted� TypeError� RaisesExc� ValueError�callable�type)r0 r9 r: �__tracebackhide__�msgr8 �excinfos r1 r2 r2 h s � �R �� � �v�;�A� A�J�C� �4�9�9�V�F�^�,� ,�C� �8� 8�C��C�.� � � %� �&�v�&� &��+�6�v�6�6� ��Q�Rd�Qg� hN� O� � � ��7�D� �D�>�>��4�(�/�$�t�*� �=O�P�Q�Q� �%� &�'� �d�1�2�h�!�&�!� '��� � '� &�� �s �: C�C# � C �#C&c �F � U R [ :X a U R $ U $ )zJHelper function to remove redundant `re.compile` calls when printing regex)�flags�_REGEX_NO_FLAGS�pattern)r+ s r1 �_match_patternrM : s � � !�K�K�?� :�5�=�=�E��Er3 c � � [ U 5 $ )zbGet the repr of a ``check`` parameter. Split out so it can be monkeypatched (e.g. by hypothesis) )�repr)�funs r1 � repr_callablerQ ? s � � ��9�r3 c � � SU - S- $ )N�`r/ ��ss r1 � backquoterV G s � � ��7�S�=�r3 c � � [ U [ 5 ( a U R $ [ U 5 S:X a U S R $ SSR S U 5 5 - S- $ )Nr= r �(r< c 3 �8 # � U H oR v � M g 7fr. )�__name__)�.0�ees r1 � <genexpr>�'_exception_type_name.<locals>.<genexpr>R s � � �3��2�;�;��s ��))� isinstancerE rZ �lenr? ��es r1 �_exception_type_namerd K sS � � �!�T����z�z�� �1�v��{���t�}�}� � ����3��3�3� 3�c� 9�9r3 c �> � U b U S:X a g [ UU 5 ( d� [ [ [ U5 5 S- 5 n[ [ U 5 5 n[ U[ 5 ( a2 [ U [ 5 ( a [ U [ 5 ( d SU SU 3$ U SU 3$ g )Nr/ z()zUnexpected nested z , expected z is not an instance of )r` rV rd rE r' � issubclass)� expected_type� exception�actual_type_str�expected_type_strs r1 �_check_raw_typerk U s� � � � � �� 3�� ��� � � $�$8��i� �$I�D�$P�Q�� %�&:�=�&I� J�� �y�"4� 5� 5��=�$�/�/� �}�.@�A�A�'��'8� �DU�CV�W� W�!�"�"9�:K�9L�M�M� r3 c �R ^ ^� Sm[ UU 4S j[ T 5 5 5 ( + $ )Nz {}()+.*?^$[]c 3 �n ># � U H* u pUT; =( a US :H =( d TUS- S:g v � M, g7f)r r= �\Nr/ )r[ �i�c�metacharactersrU s ��r1 r] �#is_fully_escaped.<locals>.<genexpr>o s9 �� � � �KW��!��^��<��a��!;�1�Q��U�8�t�+;�<�<�s �25)�any� enumerate)rU rq s `@r1 �is_fully_escapedru l s, �� �#�N�� �KT�UV�<�� � � r3 c �2 � [ R " SSU 5 $ )Nz\\([{}()+-.*?^$\[\]\s\\])z\1)�re�subrT s r1 �unescapery t s � � �6�6�.��q� 9�9r3 c � � \ rS rSrSr S S jr S S jr\S S j5 r SS jr SS jr \ SS j5 r S r g )�AbstractRaisesi~ zFABC with common functionality shared between RaisesExc and RaisesGroupc � � [ U[ 5 ( aT S n [ R " U5 U l Ub [ SU 35 US:X a [ R " [ S5 SS9 OXl S U l [ U[ 5 ( d) [ U[ 5 ( at UR [ :X a` [ U[ 5 ( a UR nU( a8 US S:X a/ US S :X a& [ US S 5 ( a [! US S 5 U l X l S U l S U l S U l g ! [ R a nUn S nAGNS nAff = f) Nz+Invalid regex pattern provided to 'match': r) z�matching against an empty string will *always* pass. If you want to check for an empty message you need to pass '^$'. If you don't want to match you should pass `None` or leave out the parameter.� )� stacklevelr �^����$r= F)r` �strrw �compiler+ �errorr �warnings�warnr �rawmatchr rJ rK rL ru ry r, � _fail_reason�_nested�is_baseexception)�selfr+ r, �re_errorrc s r1 �__init__�AbstractRaises.__init__� s. � � �e�S� !� !��H� �24�*�*�U�2C�� � �#��B�8�*�M�N���{�� � �!�[�� !� �� �J� %)�� � �e�S� !� !� �u�g� &� &�5�;�;�/�+I��%��)�)� � � ����!�H��O��"�I��$�$�U�1�R�[�1�1� (��q��� 5�� �� �(,��� #�� � !&�� ��O �8�8� � ��� �s �D1 �1E�E � Ec �D � [ U[ 5 ( a3 [ U[ 5 ( a [ U[ 5 ( d SU l U$ [ U5 nU( a� [ U[ 5 ( a� [ U5 S n[ U[ 5 ( a U[ [ 4; d% [ U[ 5 ( aC U[ [ 4; a3 [ U[ 5 ( d SU l [ [ [ U5 $ [ SU S35 eSU S3n[ U[ 5 ( a [ XQR < - 5 e[ U[ 5 ( a% [ US[ U5 R S3- 5 e[ U[! [ U5 R 5 - 5 e) NTr zoOnly `ExceptionGroup[Exception]` or `BaseExceptionGroup[BaseException]` are accepted as generic types but got `z�`. As `raises` will catch all instances of the specified group regardless of the generic argument specific nested exceptions has to be checked with `RaisesGroup`.�expected exception must be �, not zan exception instance (r_ )r` rE rf � BaseException� Exceptionr� r r' r r( r r r! rC rZ rA rO )r� �exc�expected� origin_exc�exc_typerG s r1 � _parse_exc�AbstractRaises._parse_exc� sa � � �c�4� � �Z��]�%C�%C� �c�9�-�-�(,��%��J� 2<�C� � � �*�Z�1C�D�D� ��}�Q�'�H��:�~�6�6�8� �SV�GW�;W��:�'9�:�:� � �� 4�4�!�#�y�1�1�,0�D�)��D�� ,�j�9�9� �>�>A�U� C*�+�� � ,�H�:�V�<�� �c�4� � � �S�l�l�%5� 6�7� 7� �c�=� )� )��C�$;�D��I�<N�<N�;O�q�"Q� Q�R� R���d�4��9�#5�#5� 6�6�7�7r3 c � � U R $ )z�Set after a call to :meth:`matches` to give a human-readable reason for why the match failed. When used as a context manager the string will be printed as the reason for the test failing.)r� �r� s r1 � fail_reason�AbstractRaises.fail_reason� s � � � � � r3 c � � U R c gU R U5 ( a gU R ( a SOS[ U R 5 - nSU S3U l g)NTr) � r, z did not return TrueF)r, r� rQ r� )r� rh � check_reprs r1 � _check_check�AbstractRaises._check_check� sS � � �:�:� �� �:�:�i� � �� �<�<�R�S�=����3L�-L� � #�J�<�/C� D���r3 c �P � U R b0 [ R " U R [ USS9=n5 ( a g[ U[ 5 ( a S[ [ U5 5 S3OSn[ U R [ 5 ( aG SSK J n SS K J n U" U R X%5 nUS S S :X a S OSS R U5 - U l gS U S [ U R 5 < SU< 3U l [ U R 5 U:X a U =R S- sl g)NF)�include_subexception_msgTz the `z()`r) r )� _diff_text)�dummy_highlighter�-� zRegex pattern did not matchz . Regex: z Input: z* Did you mean to `re.escape()` the regex?)r+ rw �searchr r` r' rd rE r� r� �_pytest.assertion.utilr� r� r? r� rM )r� rc �stringified_exception�maybe_specify_typer� r� �diffs r1 � _check_match�AbstractRaises._check_match� s$ � � �:�:� ���� �J�J�%8��E�&� � !�" � " � � �!� /�0�0� �)�$�q�'�2�3�3� 7�� � �d�m�m�S� )� )� :� @� �d�m�m�-B�V�D�)-�a����s�):���d�i�i�PT�o� U�D� �� *�*<�)=� >�%�d�j�j�1�4� 5�,�/� 1� �� �$�*�*� %�)>� >� � � �!N� N� �r3 c � � g)z�Check if an exception matches the requirements of this AbstractRaises. If it fails, :meth:`AbstractRaises.fail_reason` should be set. Nr/ �r� rh s r1 �matches�AbstractRaises.matches s � r3 )r� r� r, r� r+ r� N)r+ �str | Pattern[str] | Noner, z$Callable[[BaseExcT_co], bool] | None�return�None)r� z%type[BaseExcT_1] | types.GenericAliasr� r� r� ztype[BaseExcT_1])r� � str | None)r� �AbstractRaises[BaseExcT_1]rh r! r� �bool)rc r� r� r� )r� r� rh r� r� zTypeGuard[BaseExcT_1])rZ � __module__� __qualname__�__firstlineno__�__doc__r� r� �propertyr� r� r� r r� �__static_attributes__r/ r3 r1 r{ r{ ~ s� � �P�2&� )�2&� 4� 2&� � 2&�h#8�8�#8�DG�#8� �#8�J �!� �!� �(� � � � � � #�J � �(� �5B� � � � � r3 r{ c � ^ � \ rS rSrSr\SSS. SS jj5 r\SS. SS jj5 r\SS j5 r SS S S. SU 4S jjjjr SS jrSS jrSS jr SS jr SS jr Sr U =r $ )rB i az .. versionadded:: 8.4 This is the class constructed when calling :func:`pytest.raises`, but may be used directly as a helper class with :class:`RaisesGroup` when you want to specify requirements on sub-exceptions. You don't need this if you only want to specify the type, since :class:`RaisesGroup` accepts ``type[BaseException]``. :param type[BaseException] | tuple[type[BaseException]] | None expected_exception: The expected type, or one of several possible types. May be ``None`` in order to only make use of ``match`` and/or ``check`` The type is checked with :func:`isinstance`, and does not need to be an exact match. If that is wanted you can use the ``check`` parameter. :kwparam str | Pattern[str] match: A regex to match. :kwparam Callable[[BaseException], bool] check: If specified, a callable that will be called with the exception as a parameter after checking the type and the match regex if specified. If it returns ``True`` it will be considered a match, if not it will be considered a failed match. :meth:`RaisesExc.matches` can also be used standalone to check individual exceptions. Examples:: with RaisesGroup(RaisesExc(ValueError, match="string")) ... with RaisesGroup(RaisesExc(check=lambda x: x.args == (3, "hello"))): ... with RaisesGroup(RaisesExc(check=lambda x: type(x) is ValueError)): ... .r* c � � g r. r/ )r� r0 r+ r, s r1 r� �RaisesExc.__init__M � � � r3 r4 c � � g r. r/ )r� r+ r, s r1 r� r� Y � � � r3 c � � g r. r/ )r� r, s r1 r� r� c s � �NQr3 Nc �� >^ � [ TT ] X#S9 [ U[ 5 ( a UnO Uc SnOU4nUS:X a Uc Uc [ S5 e[ U 4S jU 5 5 T l ST l g )Nr* r/ z4You must specify at least one parameter to match on.c 3 �D ># � U H nTR US S9v � M g7f)za BaseException type)r� N)r� �r[ rc r� s �r1 r] �%RaisesExc.__init__.<locals>.<genexpr>{ s& �� � � ) �(�� �O�O�A�(>�O� ?�(�s � F)�superr� r` �tuplerC �expected_exceptions�_just_propagate)r� r0 r+ r, r� � __class__s ` �r1 r� r� f s~ �� � ���u��2� �(�%� 0� 0�"4� � � '�"$� �#5�"7� � �2� %�5�=�U�]� � S�T� T�#(� ) �(�) � $ �� � %�� r3 c � � SU l Uc SU l gU R U5 ( d SU l gU R U5 ( d gU R U5 $ )a� Check if an exception matches the requirements of this :class:`RaisesExc`. If it fails, :attr:`RaisesExc.fail_reason` will be set. Examples:: assert RaisesExc(ValueError).matches(my_exception): # is equivalent to assert isinstance(my_exception, ValueError) # this can be useful when checking e.g. the ``__cause__`` of an exception. with pytest.raises(ValueError) as excinfo: ... assert RaisesExc(SyntaxError, match="foo").matches(excinfo.value.__cause__) # above line is equivalent to assert isinstance(excinfo.value.__cause__, SyntaxError) assert re.search("foo", str(excinfo.value.__cause__) F�exception is NoneT)r� r� � _check_typer� r� r� s r1 r� �RaisesExc.matches� s^ � �, %�� � � � 3�D� ��� � � �*�*�#'�D� ��� � ��+�+��� � ��+�+r3 c �l � / nU R ( a$ UR [ U R 5 5 U R b( UR S[ U R 5 < 35 U R b' UR S[ U R 5 35 SSR U5 S3$ )N�match=�check=z RaisesExc(r< r_ )r� �appendrd r+ rM r, rQ r? )r� � parameterss r1 �__repr__�RaisesExc.__repr__� s� � �� � � #� #� � � � 2�4�3K�3K� L� M� �:�:� !� � � �� �� � �3�6�7� � �:�:� !� � � ��}�T�Z�Z�'@�&A� B� C��D�I�I�j� 1�2�!�4�4r3 c �T � [ U R U5 U l U R S L $ r. )rk r� r� r� s r1 r� �RaisesExc._check_type� s( � � +�D�,D�,D�i� P���� � �D�(�(r3 c �N � [ R " 5 U l U R $ r. �r � for_laterrH r� s r1 � __enter__�RaisesExc.__enter__� s � �;H�;R�;R�;T�� ��|�|�r3 c �� � SnUcj U R ( d [ S5 [ U R 5 S:� a [ SU R < 35 [ SU R S < 35 U R c S5 eU R U5 ( d' U R ( a g[ U R 5 e[ S XU45 nU R R U5 g) NTzDID NOT RAISE any exceptionr= zDID NOT RAISE any of zDID NOT RAISE r �:Internal error - should have been constructed in __enter__FzJtuple[type[BaseExcT_co_default], BaseExcT_co_default, types.TracebackType]) r� r ra rH r� r� �AssertionErrorr� r � fill_unfilled)r� r� �exc_val�exc_tbrF �exc_infos r1 �__exit__�RaisesExc.__exit__� s� � � !�� � ��+�+��2�3��4�+�+�,�q�0��,�T�-E�-E�,H�I�J� �>�$�":�":�1�"=�!@�A� B��|�|�'� � H� �'� �|�|�G�$�$��#�#� � ��!2�!2�3� 3� � X� �� '� �� � � �"�"�8�,�r3 )r� r� rH r� )r0 zAtype[BaseExcT_co_default] | tuple[type[BaseExcT_co_default], ...]r+ r� r, �,Callable[[BaseExcT_co_default], bool] | Noner� r� )r� �RaisesExc[BaseException]r+ r� r, z&Callable[[BaseException], bool] | Noner� r� )r, � Callable[[BaseException], bool]r� r� r. )r0 zHtype[BaseExcT_co_default] | tuple[type[BaseExcT_co_default], ...] | Noner+ r� r, r� )rh �BaseException | Noner� � TypeGuard[BaseExcT_co_default]�r� r� )rh r� r� r� )r� z"ExceptionInfo[BaseExcT_co_default]�r� ztype[BaseException] | Noner� r� r� ztypes.TracebackType | Noner� r� )rZ r� r� r� r� r r� r� r� r� r� r� r� � __classcell__�r� s @r1 rB rB s/ �� �%�Z � ,/�>A� � N� � )� � <� � � � � � � 9<� �&�� )� � 6� � �� �� �Q� �Q� � %� ,0�>B�%� U�%� )�%� <�%� %�8!,�'�!,� (�!,�F 5�)� � �,� � &� � +� � � � r3 rB c �p ^ � \ rS rSrSr\SS. S"S jj5 r\SSS. S#S jj5 r\SSS. S$S jj5 r\SSS. S%S jj5 r\SSS. S&S jj5 r\SSS. S'S jj5 r\SSS. S(S jj5 r\SSS. S)S jj5 rSSSSS. S*U 4S jjjr S+U 4S jjr\ S,S j5 r\ S-S j5 rS.S jrS/S jr S0S jr \ S1S j5 r \ S2S j5 r S3S jr \ S4S j5 r \ S5S j5 r\ S6S j5 r\ S7S j5 r S8S jr S9S jrS/S jrS!rU =r$ ):� RaisesGroupi� a .. versionadded:: 8.4 Contextmanager for checking for an expected :exc:`ExceptionGroup`. This works similar to :func:`pytest.raises`, but allows for specifying the structure of an :exc:`ExceptionGroup`. :meth:`ExceptionInfo.group_contains` also tries to handle exception groups, but it is very bad at checking that you *didn't* get unexpected exceptions. The catching behaviour differs from :ref:`except* <except_star>`, being much stricter about the structure by default. By using ``allow_unwrapped=True`` and ``flatten_subgroups=True`` you can match :ref:`except* <except_star>` fully when expecting a single exception. :param args: Any number of exception types, :class:`RaisesGroup` or :class:`RaisesExc` to specify the exceptions contained in this exception. All specified exceptions must be present in the raised group, *and no others*. If you expect a variable number of exceptions you need to use :func:`pytest.raises(ExceptionGroup) <pytest.raises>` and manually check the contained exceptions. Consider making use of :meth:`RaisesExc.matches`. It does not care about the order of the exceptions, so ``RaisesGroup(ValueError, TypeError)`` is equivalent to ``RaisesGroup(TypeError, ValueError)``. :kwparam str | re.Pattern[str] | None match: If specified, a string containing a regular expression, or a regular expression object, that is tested against the string representation of the exception group and its :pep:`678` `__notes__` using :func:`re.search`. To match a literal string that may contain :ref:`special characters <re-syntax>`, the pattern can first be escaped with :func:`re.escape`. Note that " (5 subgroups)" will be stripped from the ``repr`` before matching. :kwparam Callable[[E], bool] check: If specified, a callable that will be called with the group as a parameter after successfully matching the expected exceptions. If it returns ``True`` it will be considered a match, if not it will be considered a failed match. :kwparam bool allow_unwrapped: If expecting a single exception or :class:`RaisesExc` it will match even if the exception is not inside an exceptiongroup. Using this together with ``match``, ``check`` or expecting multiple exceptions will raise an error. :kwparam bool flatten_subgroups: "flatten" any groups inside the raised exception group, extracting all exceptions inside any nested groups, before matching. Without this it expects you to fully specify the nesting structure by passing :class:`RaisesGroup` as expected parameter. Examples:: with RaisesGroup(ValueError): raise ExceptionGroup("", (ValueError(),)) # match with RaisesGroup( ValueError, ValueError, RaisesExc(TypeError, match="^expected int$"), match="^my group$", ): raise ExceptionGroup( "my group", [ ValueError(), TypeError("expected int"), ValueError(), ], ) # check with RaisesGroup( KeyboardInterrupt, match="^hello$", check=lambda x: isinstance(x.__cause__, ValueError), ): raise BaseExceptionGroup("hello", [KeyboardInterrupt()]) from ValueError # nested groups with RaisesGroup(RaisesGroup(ValueError)): raise ExceptionGroup("", (ExceptionGroup("", (ValueError(),)),)) # flatten_subgroups with RaisesGroup(ValueError, flatten_subgroups=True): raise ExceptionGroup("", (ExceptionGroup("", (ValueError(),)),)) # allow_unwrapped with RaisesGroup(ValueError, allow_unwrapped=True): raise ValueError :meth:`RaisesGroup.matches` can also be used directly to check a standalone exception group. The matching algorithm is greedy, which means cases such as this may fail:: with RaisesGroup(ValueError, RaisesExc(ValueError, match="hello")): raise ExceptionGroup("", (ValueError("hello"), ValueError("goodbye"))) even though it generally does not care about the order of the exceptions in the group. To avoid the above you should specify the first :exc:`ValueError` with a :class:`RaisesExc` as well. .. note:: When raised exceptions don't match the expected ones, you'll get a detailed error message explaining why. This includes ``repr(check)`` if set, which in Python can be overly verbose, showing memory locations etc etc. If installed and imported (in e.g. ``conftest.py``), the ``hypothesis`` library will monkeypatch this output to provide shorter & more readable repr's. F)�flatten_subgroupsc � � g r. r/ )r� r0 �allow_unwrappedr� s r1 r� �RaisesGroup.__init__P r� r3 Nr* c � � g r. r/ )r� r0 r� r+ r, �other_exceptionss r1 r� r� [ s � � r3 c � � g r. r/ �r� r0 r+ r, r� s r1 r� r� k r� r3 c � � g r. r/ r� s r1 r� r� u r� r3 c � � g r. r/ r� s r1 r� r� r� r3 c � � g r. r/ r� s r1 r� r� � r� r3 c � � g r. r/ r� s r1 r� r� � r� r3 c � � g r. r/ r� s r1 r� r� � s � �$ r3 )r� r� r+ r, c �P >^ � [ SU5 n[ TT ] XES9 UT l UT l ST l U( a U( a [ S5 eU( a [ U[ 5 ( a [ S5 eU( a Uc Ub [ S5 e[ U 4S jU/UQ7 5 5 T l g )NzVCallable[[BaseExceptionGroup[ExcT_1|BaseExcT_1|BaseExceptionGroup[BaseExcT_2]]], bool]r* Fz�You cannot specify multiple exceptions with `allow_unwrapped=True.` If you want to match one of multiple possible exceptions you should use a `RaisesExc`. E.g. `RaisesExc(check=lambda e: isinstance(e, (...)))`z�`allow_unwrapped=True` has no effect when expecting a `RaisesGroup`. You might want it in the expected `RaisesGroup`, or `flatten_subgroups=True` if you don't care about the structure.ax `allow_unwrapped=True` bypasses the `match` and `check` parameters if the exception is unwrapped. If you intended to match/check the exception you should use a `RaisesExc` object. If you want to match/check the exceptiongroup when the exception *is* wrapped you need to do e.g. `if isinstance(exc.value, ExceptionGroup): assert RaisesGroup(...).matches(exc.value)` afterwards.c 3 �H ># � U H nTR US 5 v � M g7f)z/a BaseException type, RaisesExc, or RaisesGroupN)�_parse_excgroupr� s �r1 r] �'RaisesGroup.__init__.<locals>.<genexpr>� s- �� � � ��� � � ��$U� V� V��s � ") r r� r� r� r� r� rC r` r� r� r� )r� r0 r� r� r+ r, r� r� s ` �r1 r� r� � s� �� �* � d� � �� ���u��2� .�� �'8�� � %�� � � /� �J�� � �z�*<�k� J� J� �S�� � �� 1�U�5F� �K�� � � � #��!�� � � � r3 c �� >� [ U[ 5 ( aD U R ( a [ S5 eU =R UR - sl SUl U$ [ U[ 5 ( a( U =R UR - sl SUl U$ [ U[ 5 ( a& [ SU S[ U5 R < S35 e[ TU ]1 X5 $ )Nz�You cannot specify a nested structure inside a RaisesGroup with `flatten_subgroups=True`. The parameter will flatten subgroups in the raised exceptiongroup before matching, which would never match a nested structure.Tr� r� z�. RaisesGroup does not support tuples of exception types when expecting one of several possible exception types like RaisesExc. If you meant to expect a group with multiple exceptions, list them as separate arguments.) r` r� r� rC r� r� rB r� rA rE rZ r� r� )r� r� r� r� s �r1 r �RaisesGroup._parse_excgroup� s� �� � �c�;� '� '��%�%� �1�� � � !� !�S�%9�%9� 9� !� �C�K��J� ��Y� '� '� � !� !�S�%9�%9� 9� !� �C�K��J� ��U� #� #��-�h�Z�v�d�3�i�>P�>P�=S� Tl� l�� � �7�%�c�4� 4r3 c � � g r. r/ r� s r1 r� �RaisesGroup.__enter__ s � � 14r3 c � � g r. r/ r� s r1 r� r s � � 9<r3 c �N � [ R " 5 U l U R $ r. r� r� s r1 r� r " s! � � � #� #� %� � � �|�|�r3 c �P � U R Vs/ s H/ n[ U[ 5 ( a UR O [ U5 PM1 nnU R ( a UR SU R 35 U R ( a UR SU R 35 U R b( UR S[ U R 5 < 35 U R b' UR S[ U R 5 35 SSR U5 S3$ s snf )Nzallow_unwrapped=zflatten_subgroups=r� r� z RaisesGroup(r< r_ ) r� r` rE rZ rO r� r� r� r+ rM r, rQ r? )r� rc �reqss r1 r� �RaisesGroup.__repr__( s� � � �-�-� �-�� %�Q��-�-�A�J�J�4��7� :�-� � � � � � �K�K�*�4�+?�+?�*@�A� B� � !� !� �K�K�,�T�-C�-C�,D�E� F� �:�:� !� �K�K�&� �� � �!;� >�?� @� �:�:� !� �K�K�&� �t�z�z�!:� ;�<� =� �d�i�i��o� .�a�0�0�� s �6D#c � � / nU HU n[ U[ 5 ( a, UR U R UR 5 5 MD UR U5 MW U$ )z!Used if `flatten_subgroups=True`.)r` r' �extend�_unroll_exceptions� exceptionsr� )r� r �resr� s r1 r � RaisesGroup._unroll_exceptions8 sP � � $&�� �C��#� 1�2�2�� � �4�2�2�3�>�>�B�C� � � �3�� � � r3 c � � g r. r/ r� s r1 r� �RaisesGroup.matchesF s � � -0r3 c � � g r. r/ r� s r1 r� r K s � � 58r3 c � � SU l Uc SU l g[ U[ 5 ( d� S[ U5 R S3n[ U R 5 S:� a X l gU R U R S U5 nUc U R ( a gUc U S 3U l gU R ( a X0l gX l gUR nU R ( a U R U5 nU R U5 ( Gd& [ [ U R 5 U l U R n[ U5 [ U R 5 s=:X a S:X a� O O�[ U R S =n[ 5 ( a� [ US =ov5 ( a� U R U5 ( ay U R c S 5 eU R Us=L a c e eU =R S U R! U5 S UR S [# U R 5 < S3- sl gXPl gU R% UU5 ( d� [ [ U R 5 U l U R c eU R nU R ( d� [' S U R 5 5 ( dj [' S U 5 5 ( aS U R% UU R UR 5 5 ( a# SU R ; a SOSnUSU S3- U l gXPl gU R) U5 ( d� [ [ U R 5 S[ U5 R 3- n [ U5 [ U R 5 s=:X a S:X ak O Oh[ U R S =n[ 5 ( aD U R) US 5 ( a+ U SU R! U5 SUR S3- U l gX�l gg)a� Check if an exception matches the requirements of this RaisesGroup. If it fails, `RaisesGroup.fail_reason` will be set. Example:: with pytest.raises(TypeError) as excinfo: ... assert RaisesGroup(ValueError).matches(excinfo.value.__cause__) # the above line is equivalent to myexc = excinfo.value.__cause assert isinstance(myexc, BaseExceptionGroup) assert len(myexc.exceptions) == 1 assert isinstance(myexc.exceptions[0], ValueError) Nr� FrS z ()` is not an exception groupr= r Tz-, but would match with `allow_unwrapped=True`z$can't be None if _check_match failedz but matched the expected `z*`. You might want `RaisesGroup(RaisesExc(z, match=z))`c 3 �B # � U H n[ U[ 5 v � M g 7fr. )r` r� �r[ rc s r1 r] �&RaisesGroup.matches.<locals>.<genexpr>� s � � � �8P�1�J�q�+�.�.�8P�� � c 3 �B # � U H n[ U[ 5 v � M g 7fr. )r` r' r s r1 r] r � s � � �U�CT�a� �1�&8�9�9�CT�r r� � r) z-Did you mean to use `flatten_subgroups=True`?z on the z', but did return True for the expected z'. You might want RaisesGroup(RaisesExc(z, check=<...>)))r� r` r' rE rZ ra r� �_check_expectedr� r r� r r� r r� r+ �_repr_expectedrM �_check_exceptionsrs r� ) r� rh � not_group_msgr �actual_exceptions� old_reasonr� �actualr �reasons r1 r� r Q s� � �$ !��� � � 3�D� ���)�%7�8�8� ��Y�� 8� 8� 9�9V� W�M��4�+�+�,�q�0�$1�!� � �&�&�t�'?�'?��'B�I�N�C��{�t� 3� 3���{�$�o�%R�S� �!� � �%�%�$'�!� � %2�!��5>�5I�5I�� � !� !� $� 7� 7�8I� J� �� � ��+�+� $�S�$�*;�*;� <�D� � �*�*�J��%�&�#�d�.F�.F�*G�L�1�L� �4�+C�+C�A�+F� F�x��M�M� �):�1�)=� =�v�H�H��%�%�f�-�-��z�z�-�U�/U�U�-��(�(�J�B�B�B�B�B��!�!�2�26�2E�2E�h�2O�1P� Q.�.6�.?�.?�-@�� �X\�Xb�Xb�Ic�Hf�fi�k��!� � %/�!�� �%�%� � � � � !%�S�$�*;�*;� <�D� ��$�$�0� 0�0� �*�*�J� �*�*�� �8<�8P�8P� � � � �U�CT�U�U�U��*�*� ��+�+�I�,@�,@�A�� � "&�T�->�->�!>��B�� ��6�(�"O�P�Q� �!� � %/�!�� � � ��+�+��S�$�+�+�,��$�y�/�:R�:R�9S�/T�T� � �%�&�#�d�.F�.F�*G�L�1�L� �4�+C�+C�A�+F� F�x��M�M��%�%�&7��&:�;�;�$*�=�d�>Q�>Q�RZ�>[�=\� ]=�=E�=N�=N�<O��`�%��!� � %+�!��r3 c �0 � [ U [ 5 ( a [ X5 $ U R U5 nU( a gU R c eU R R S5 ( a SU < S[ U R S5 3$ U < SU R 3$ )z�Helper method for `RaisesGroup.matches` and `RaisesGroup._check_exceptions` to check one of potentially several expected exceptions.Nr� z: r )r` rE rk r� r� � startswithr )rg rh r s r1 r �RaisesGroup._check_expected� s� � � �m�T� *� *�"�=�<� <��#�#�I�.�� �� �(�(�4�4�4� � $� $� /� /�� 5� 5�� �(��6�-�2K�2K�T�+R�*S�T� T� �"�"�]�%>�%>�$?�@�@r3 c �X � [ U [ 5 ( a [ U 5 $ [ U 5 $ )z`Get the repr of an expected type/RaisesExc/RaisesGroup, but we only want the name if it's a type)r` rE rd rO rb s r1 r! �RaisesGroup._repr_expected� s% � � �a�� � �'��*� *��A�w�r3 c � � g r. r/ �r� � _exceptionr$ s r1 r" � RaisesGroup._check_exceptions� s � � -0r3 c � � g r. r/ r. s r1 r" r0 � s � � 58r3 c � ^ � [ T R U5 n[ [ [ U5 5 5 n/ n0 n[ T R 5 H` u pxU HD n T R X�U 5 n UR XyU 5 U b M. UR U 5 X�U' MM UR U5 Mb U( d U( d gS[ U5 s=:X a [ T R 5 :X a O OU( a eW T l g[ T R 5 HR u px[ U5 H> u p�UR X{5 ( a M UR X{T R X�5 5 M@ MT U( a" [ U5 S[ U5 S:� a SOS S3OSn U( d7 UR U5 ( a! U SU Vs/ s H o�U PM sn< 3T l gU( d? UR U5 ( a) S R U 4S jU 5 5 nU S U S 3T l gS[ U5 s=:X a [ U5 :X aQ O ONUR U5 ( a8 UR U5 ( a" U UR US US 5 3T l gSnU( a USU 3- nSnSnU( d US- nO U( d US- nU( a+ US- nUR! 5 VVs0 s H u nnUU_M nnnU H� nUSU T R# T R U 5 3- n[ U5 Hc u p�UR WU 5 b M USU S[% [' U 5 5 S3[% T R# T R WU 5 5 - - nMe M� U( a US- nU H� n USU X+ < S3- n[ T R 5 H u pxUR X{5 n Xu; a" U c eU S S:w a US- nU[) U U5 - nU b MB USU S[% T R# U5 5 S[% [' X&U 5 5 3- nM� M� [ T R 5 [ U5 :X a [+ U5 ( a US- nUT l gs snf s snnf )z]Helper method for RaisesGroup.matches that attempts to pair up expected and actual exceptionsTr= Fz matched exceptionrU r) z. zUnexpected exception(s): r< c 3 �` ># � U H# nTR TR U 5 v � M% g 7fr. )r! r� )r[ ro r� s �r1 r] �0RaisesGroup._check_exceptions.<locals>.<genexpr>5 s1 �� � � )�(�A� �#�#�D�$<�$<�Q�$?�@�@�(�s �+.z0Too few exceptions raised, found no match for: [�]r r� r z z Too few exceptions raised!z Unexpected exception(s)!z8 The following expected exceptions did not find a match:z It matches z which was paired with z5 The following raised exceptions did not find a match�:z� There exist a possible match when attempting an exhaustive check, but RaisesGroup uses a greedy algorithm. Please make your expected exceptions more stringent with `RaisesExc` etc so the greedy algorithm can function.)� ResultHolderr� �list�rangera rt r � set_result�remover� r� � has_result�no_match_for_actual�no_match_for_expectedr? � get_result�itemsr! rV rO r �possible_match)r� r/ r$ �results�remaining_actual�failed_expectedr� �i_expr� �i_remr �i_actualr& �successful_strro �no_match_for_strrU �indent_1�indent_2�k�v� rev_matches�i_faileds ` r1 r" r0 � s� �� � �t� 7� 7�9J�K�� ��c�*;�&<� =�>��%'��"$�� )��)A�)A� B�O�E�)���*�*�8�u�5M�N���"�"�5��5��;�$�+�+�E�2�%*�E�N�� *� �&�&�u�-� C� ��� ��%�&� G�#�d�.F�.F�*G� G� � �;� #�D� �� )��)A�)A� B�O�E�$-�.?�$@� ���%�%�e�6�6� ��"�"��T�%9�%9�(�%K�� %A� C� � �7�|�n� .�c�'�l�Q�6F�s�B�.O�r� R�� � �7�#>�#>�?O�#P�#P�!�"� #�3C�D�3C�a�q�)�3C�D�G�I� � � � �G�$A�$A�/�$R�$R� #�y�y� )�(�)� � � $2�"2�2b�cs�bt�tu� v�D� �� ��%�&� >�#�o�*>� >��+�+�,<�=�=��-�-�o�>�>�#1�"2�7�3E�3E�o�VW�FX�Zj�kl�Zm�3n�2o� p�D� �� �� � �2�n�%�&� &�A����� � �/� /�A� � �-� -�A� � �L� L�A�,3�M�M�O�<�O�D�A�q�1�a�4�O�K�<�'�H� ��X�J�t� 2� 2�4�3K�3K�H�3U� V� W�X� �A� %.�.?�$@� ���%�%�e�X�6�>�� �X�J�k�)�D��L�2I�1J�Ja�b�#� � /� /� $� 8� 8��X�9N� O� ����A� %A� (� � �I� I�A�(�H� �2�h�Z� 1� ;� >�a�@� @�A�#,�T�-E�-E�#F��� �(�(��9���+� �?�*�?��1�v��~��T� �����X�.�.�A��;�� �X�J�k�)�D�<O�<O�PX�<Y�2Z�1[� \1�1:�4�@Q�Z_�R`�@a�;b�1c�0d�f��A� $G� )� �t�'�'� (�C�0A�,B� B�~� �H � H � �9� �A� �����c E��H =s �8R�Rc �x � SnUc [ SU R 5 S35 U R c S5 eU R ( a [ U[ 5 ( d SOSnU R U5 ( d [ SU SU R 35 [ S XU45 nU R R U5 g) NTz'DID NOT RAISE any exception, expected `rS r� z(group)�groupzRaised exception z did not match: zbtuple[type[BaseExceptionGroup[BaseExcT_co]], BaseExceptionGroup[BaseExcT_co], types.TracebackType]) r rg rH r� rf r' r� r� r r� )r� r� r� r� rF � group_strr� s r1 r� �RaisesGroup.__exit__� s� � � !�� � � �:�4�;M�;M�;O�:P�PQ�R� S��|�|�'� � H� �'� �#�#�J�x�AS�,T�,T� �� � �|�|�G�$�$� �$�Y�K�/?��@Q�@Q�?R�S� T� � p� �� '� �� � � �"�"�8�,�r3 c �� � / nU R H� n[ U[ 5 ( a UR [ U5 5 M4 [ U[ 5 ( a! UR UR 5 5 Mj [ U[ 5 ( a UR UR 5 M� [ S5 e U R ( a SOSnU SSR U5 S3$ )Nz unknown type�Baser) zExceptionGroup(r< r_ ) r� r` rB r� rO r� rg rE rZ r� r� r? )r� �subexcsrc � group_types r1 rg �RaisesGroup.expected_type� s� � ����)�)�A��!�Y�'�'����t�A�w�'��A�{�+�+����q��� 0�1��A�t�$�$����q�z�z�*�$�^�4�4� *� $� 4� 4�V�"� � � �_�T�Y�Y�w�-?�,@��B�Br3 )r� r� rH r� r� r� )r0 �*type[BaseExcT_co] | RaisesExc[BaseExcT_co]r� � Literal[True]r� r� r� r� ) r0 rY r� rY r� rZ r+ r� r, z8Callable[[BaseExceptionGroup[BaseExcT_co]], bool] | Noner� r� ) r� �RaisesGroup[ExcT_1]r0 � type[ExcT_1] | RaisesExc[ExcT_1]r� r\ r+ r� r, z/Callable[[ExceptionGroup[ExcT_1]], bool] | Noner� r� ) r� z#RaisesGroup[ExceptionGroup[ExcT_2]]r0 �RaisesGroup[ExcT_2]r� r] r+ r� r, z?Callable[[ExceptionGroup[ExceptionGroup[ExcT_2]]], bool] | Noner� r� ) r� z,RaisesGroup[ExcT_1 | ExceptionGroup[ExcT_2]]r0 �6type[ExcT_1] | RaisesExc[ExcT_1] | RaisesGroup[ExcT_2]r� r^ r+ r� r, zHCallable[[ExceptionGroup[ExcT_1 | ExceptionGroup[ExcT_2]]], bool] | Noner� r� ) r� �RaisesGroup[BaseExcT_1]r0 �(type[BaseExcT_1] | RaisesExc[BaseExcT_1]r� r` r+ r� r, z7Callable[[BaseExceptionGroup[BaseExcT_1]], bool] | Noner� r� ) r� z+RaisesGroup[BaseExceptionGroup[BaseExcT_2]]r0 �RaisesGroup[BaseExcT_2]r� ra r+ r� r, zKCallable[[BaseExceptionGroup[BaseExceptionGroup[BaseExcT_2]]], bool] | Noner� r� ) r� z8RaisesGroup[BaseExcT_1 | BaseExceptionGroup[BaseExcT_2]]r0 �Btype[BaseExcT_1] | RaisesExc[BaseExcT_1] | RaisesGroup[BaseExcT_2]r� rb r+ r� r, zXCallable[[BaseExceptionGroup[BaseExcT_1 | BaseExceptionGroup[BaseExcT_2]]], bool] | Noner� r� )r� zARaisesGroup[ExcT_1 | BaseExcT_1 | BaseExceptionGroup[BaseExcT_2]]r0 rb r� rb r� r� r� r� r+ r� r, zbCallable[[BaseExceptionGroup[BaseExcT_1]], bool] | Callable[[ExceptionGroup[ExcT_1]], bool] | None)r� zXtype[BaseExcT_co] | types.GenericAlias | RaisesExc[BaseExcT_1] | RaisesGroup[BaseExcT_2]r� r� r� zCtype[BaseExcT_co] | RaisesExc[BaseExcT_1] | RaisesGroup[BaseExcT_2])r� r[ r� z%ExceptionInfo[ExceptionGroup[ExcT_1]])r� r_ r� z-ExceptionInfo[BaseExceptionGroup[BaseExcT_1]])r� z0ExceptionInfo[BaseExceptionGroup[BaseException]]r� )r �Sequence[BaseException]r� rc )r� r[ rh r� r� �!TypeGuard[ExceptionGroup[ExcT_1]])r� r_ rh r� r� �)TypeGuard[BaseExceptionGroup[BaseExcT_1]])rh r� r� r� )rg zKtype[BaseException] | RaisesExc[BaseException] | RaisesGroup[BaseException]rh r� r� r� )rc z3type[BaseException] | AbstractRaises[BaseException]r� r� )r� r[ r/ r� r$ zSequence[Exception]r� rd )r� r_ r/ r� r$ rc r� re )r/ r� r$ rc r� r� r� )rZ r� r� r� r� r r� r r� r� r r� � staticmethodr r! r" r� rg r� r� r� s @r1 r� r� � s" �� �m�b � #(� � F�� '� � � � �� �� � ,0�JN�� F�� F� � )� � )� � H�� �� �� � ,0�AE� �!�� <�� <� � )� � ?� � �� �� � ,0�QU� �1�� /�� /� � )� � O� � �� �� � ,0� � �:� � R� � R� � )� � U� � � � � � � ,0�IM� �%�� D�� D� � )� � G� � �� �� � ,0� � �9� � 3� � 3� � )� � X� � � � � � � ,0� �!�F�� "�� "� � )�� ��" �#� ��8 !&�"'�+/� �!= �O�= � "�= � "� = � �= � �= � )�= � �= � = �~"5� &�"5� �"5� M�"5�H �4�!�4� .�4� �4� �<�%�<� 6�<� �<� � 1� �+� � !� � �0�!�0�'�0� +�0� �0� �8�%�8�'�8� 3�8� �8� y�'�y� �y�v �A� W�A� !� A� � A� �A�$ �� �� �0�!�0� �0� /�0� +� 0� �0� �8�%�8�!�8� 3�8� 3� 8� �8� M�!�M� 3�M� � M�^ �,� � &� � +� � � �D C� Cr3 r� c � � \ rS rSrSrSrg)� NotCheckedi� z.Singleton for unchecked values in ResultHolderr/ N)rZ r� r� r� r� r� r/ r3 r1 rh rh � s � �8r3 rh c �` � \ rS rSrSr S S jrS S jrS S jrSS jrSS jr SS jr S r g )r7 i� zhContainer for results of checking exceptions. Used in RaisesGroup._check_exceptions and possible_match. c �p � U Vs/ s H o1 Vs/ s H n[ PM snPM snU l g s snf s snf r. )rh rB )r� r� r$ �_s r1 r� �ResultHolder.__init__� s? � � @Q�C �?P�!�!4� 5�!4�A�Z�!4� 5�?P�C �� �� 5��C s � 3�. �3�3c �& � X0R U U' g r. �rB )r� r� r& �results r1 r: �ResultHolder.set_result� s � �)/� � �V� �X�&r3 c �@ � U R U U nU[ Ld eU$ r. �rB rh )r� r� r& r s r1 r? �ResultHolder.get_result� s( � ��l�l�6�"�8�,���*�$�$�$�� r3 c �2 � U R U U [ L$ r. rr )r� r� r& s r1 r< �ResultHolder.has_result� s � ��|�|�F�#�H�-�Z�?�?r3 c �f � U H+ nU R H nX2 [ Ld eX2 b M g M- g�NFTrr )r� r� ro �actual_resultss r1 r> �"ResultHolder.no_match_for_expected� s< � ��A�"&�,�,��%�(� �:�:�:�!�$�,� � #/� � r3 c �d � U H* nU R U H nU[ Ld eUb M g M, grw rr )r� r& ro r s r1 r= � ResultHolder.no_match_for_actual� s9 � ��A��|�|�A����*�,�,�,��;� � '� � r3 rn N)r� z?tuple[type[BaseException] | AbstractRaises[BaseException], ...]r$ rc r� r� )r� �intr& r| ro r� r� r� )r� r| r& r| r� r� )r� r| r& r| r� r� )r� � list[int]r� r� )r& r} r� r� ) rZ r� r� r� r� r� r: r? r< r> r= r� r/ r3 r1 r7 r7 � sD � �� � � � 3� � � �0�� @��r3 r7 c �� ^ ^� Tc [ 5 m[ T5 nU[ T R 5 :X a g[ U U4S j[ T R U 5 5 5 $ )NTc 3 �v ># � U H. u pUS L =( a UT; =( a [ TTU1- 5 v � M0 g 7fr. )rA )r[ ro �valrB �useds ��r1 r] �!possible_match.<locals>.<genexpr>� s< �� � � �<�H�Q� �t� �M��� �M�.��$�!��*�*M�M�<�s �69)r> ra rB rs rt )rB r� �curr_rows `` r1 rA rA � sT �� � �|��u���4�y�H��3�w���'�'�� � �!�'�/�/�(�";�<�� � r3 )r0 � type[E] | tuple[type[E], ...]r+ z str | re.Pattern[str] | Noner, zCallable[[E], bool]r� z RaisesExc[E])r+ zstr | re.Pattern[str]r, r� r� r� )r, r� r� r� ) r0 r� r8 zCallable[..., Any]r9 r r: r r� zExceptionInfo[E]r. )r0 z$type[E] | tuple[type[E], ...] | Noner9 r r: r r� z+RaisesExc[BaseException] | ExceptionInfo[E])r+ z Pattern[str]r� zstr | Pattern[str])rP z Callable[[BaseExcT_1], bool]r� r� )rU r� r� r� )rc z5type[BaseException] | tuple[type[BaseException], ...]r� r� )rg z<type[BaseException] | tuple[type[BaseException], ...] | Nonerh r� r� r� )rU r� r� r� )rB r7 r� zset[int] | Noner� r� )D� __future__r �abcr r rw r �sys�textwrapr �typingr r r r r r r r r r� � _pytest._coder �_pytest._code.coder �_pytest.outcomesr �_pytest.warning_typesr �collections.abcr r �types�typing_extensionsr r r r r� r r r r! r" r� r# r$ � version_info�exceptiongroupr' r( r� rJ rK r2 rM rQ rV rd rk ru ry r{ rB r� rh r7 rA r/ r3 r1 �<module>r� s� �� "� � � � � � � � � � � � � � � � � '� 2� !� /� �(�(� �+�+�)��#��A� "� �� �� �� ��=�-�@�A� �!� �]�d��� �m�=�D�I� � �\� � 7� � �\� � 7� � ��� +�� ��� +�����g� �1�-� �*�*�S�/�'�'�� � +.�!$� �5�� (�� � � � � �� � .1� #� �#� +� #� � #� �#� � V� � V� ��5�� �� �� � � � � �� @D�D�<�D� �D� �D� 1� D�^ �>�>�� �F� ��:�<�:��:��O�� �� ��.�:�] �S�'�+�.� ] �@ �{�� 2�3� {� �{�| �S C�.�!3�K�!@�A� S C� �S C�l �9� 9� �9�*� *�Z r3
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка