Restoring authorship annotation for <deshevoy@yandex-team.ru>. Commit 2 of 2.

1 files changed, 141 insertions, 141 deletions

diff --git a/contrib/python/pytest/py3/_pytest/recwarn.py b/contrib/python/pytest/py3/_pytest/recwarn.py
index 3664113393..d872d9da40 100644
--- a/contrib/python/pytest/py3/_pytest/recwarn.py
+++ b/contrib/python/pytest/py3/_pytest/recwarn.py
@@ -1,6 +1,6 @@
 """Record warnings during test function execution."""
-import re 
-import warnings 
+import re
+import warnings
 from types import TracebackType
 from typing import Any
 from typing import Callable
@@ -14,35 +14,35 @@ from typing import Tuple
 from typing import Type
 from typing import TypeVar
 from typing import Union
- 
+
 from _pytest.compat import final
 from _pytest.deprecated import check_ispytest
 from _pytest.fixtures import fixture
-from _pytest.outcomes import fail 
- 
- 
+from _pytest.outcomes import fail
+
+
 T = TypeVar("T")
 
 
 @fixture
 def recwarn() -> Generator["WarningsRecorder", None, None]:
-    """Return a :class:`WarningsRecorder` instance that records all warnings emitted by test functions. 
- 
-    See http://docs.python.org/library/warnings.html for information 
-    on warning categories. 
-    """ 
+    """Return a :class:`WarningsRecorder` instance that records all warnings emitted by test functions.
+
+    See http://docs.python.org/library/warnings.html for information
+    on warning categories.
+    """
     wrec = WarningsRecorder(_ispytest=True)
-    with wrec: 
-        warnings.simplefilter("default") 
-        yield wrec 
- 
- 
+    with wrec:
+        warnings.simplefilter("default")
+        yield wrec
+
+
 @overload
 def deprecated_call(
     *, match: Optional[Union[str, Pattern[str]]] = ...
 ) -> "WarningsRecorder":
     ...
- 
+
 
 @overload
 def deprecated_call(func: Callable[..., T], *args: Any, **kwargs: Any) -> T:
@@ -56,15 +56,15 @@ def deprecated_call(
 
     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 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 
- 
+        ...    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.
@@ -74,13 +74,13 @@ def deprecated_call(
 
     The context manager produces a list of :class:`warnings.WarningMessage` objects,
     one for each warning raised.
-    """ 
-    __tracebackhide__ = True 
-    if func is not None: 
-        args = (func,) + args 
-    return warns((DeprecationWarning, PendingDeprecationWarning), *args, **kwargs) 
- 
- 
+    """
+    __tracebackhide__ = True
+    if func is not None:
+        args = (func,) + args
+    return warns((DeprecationWarning, PendingDeprecationWarning), *args, **kwargs)
+
+
 @overload
 def warns(
     expected_warning: Optional[Union[Type[Warning], Tuple[Type[Warning], ...]]],
@@ -106,130 +106,130 @@ def warns(
     match: Optional[Union[str, Pattern[str]]] = None,
     **kwargs: Any,
 ) -> Union["WarningsChecker", Any]:
-    r"""Assert that code raises a particular class of warning. 
- 
-    Specifically, the parameter ``expected_warning`` can be a warning class or 
-    sequence of warning classes, and the inside the ``with`` block must issue a warning of that class or 
-    classes. 
- 
-    This helper produces a list of :class:`warnings.WarningMessage` objects, 
-    one for each warning raised. 
- 
-    This function can be used as a context manager, or any of the other ways 
+    r"""Assert that code raises a particular class of warning.
+
+    Specifically, the parameter ``expected_warning`` can be a warning class or
+    sequence of warning classes, and the inside the ``with`` block must issue a warning of that class or
+    classes.
+
+    This helper produces a list of :class:`warnings.WarningMessage` objects,
+    one for each warning raised.
+
+    This function can be used as a context manager, or any of the other ways
     :func:`pytest.raises` can be used::
- 
+
         >>> 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 
+        ...    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) 
- 
+        ...     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) 
- 
+        ...     warnings.warn("value must be 42", UserWarning)
+
         >>> 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... was emitted... 
- 
-    """ 
-    __tracebackhide__ = True 
-    if not args: 
+        ...     warnings.warn("this is not here", UserWarning)
+        Traceback (most recent call last):
+          ...
+        Failed: DID NOT WARN. No warnings of type ...UserWarning... was emitted...
+
+    """
+    __tracebackhide__ = True
+    if not args:
         if kwargs:
             msg = "Unexpected keyword arguments passed to pytest.warns: "
             msg += ", ".join(sorted(kwargs))
             msg += "\nUse context-manager form instead?"
             raise TypeError(msg)
         return WarningsChecker(expected_warning, match_expr=match, _ispytest=True)
-    else: 
-        func = args[0] 
+    else:
+        func = args[0]
         if not callable(func):
             raise TypeError(
                 "{!r} object (type: {}) must be callable".format(func, type(func))
             )
         with WarningsChecker(expected_warning, _ispytest=True):
-            return func(*args[1:], **kwargs) 
- 
- 
-class WarningsRecorder(warnings.catch_warnings): 
-    """A context manager to record raised warnings. 
- 
-    Adapted from `warnings.catch_warnings`. 
-    """ 
- 
+            return func(*args[1:], **kwargs)
+
+
+class WarningsRecorder(warnings.catch_warnings):
+    """A context manager to record raised warnings.
+
+    Adapted from `warnings.catch_warnings`.
+    """
+
     def __init__(self, *, _ispytest: bool = False) -> None:
         check_ispytest(_ispytest)
         # Type ignored due to the way typeshed handles warnings.catch_warnings.
         super().__init__(record=True)  # type: ignore[call-arg]
-        self._entered = False 
+        self._entered = False
         self._list: List[warnings.WarningMessage] = []
- 
-    @property 
+
+    @property
     def list(self) -> List["warnings.WarningMessage"]:
-        """The list of recorded warnings.""" 
-        return self._list 
- 
+        """The list of recorded warnings."""
+        return self._list
+
     def __getitem__(self, i: int) -> "warnings.WarningMessage":
-        """Get a recorded warning by index.""" 
-        return self._list[i] 
- 
+        """Get a recorded warning by index."""
+        return self._list[i]
+
     def __iter__(self) -> Iterator["warnings.WarningMessage"]:
-        """Iterate through the recorded warnings.""" 
-        return iter(self._list) 
- 
+        """Iterate through the recorded warnings."""
+        return iter(self._list)
+
     def __len__(self) -> int:
-        """The number of recorded warnings.""" 
-        return len(self._list) 
- 
+        """The number of recorded warnings."""
+        return len(self._list)
+
     def pop(self, cls: Type[Warning] = Warning) -> "warnings.WarningMessage":
-        """Pop the first recorded warning, raise exception if not exists.""" 
-        for i, w in enumerate(self._list): 
-            if issubclass(w.category, cls): 
-                return self._list.pop(i) 
-        __tracebackhide__ = True 
-        raise AssertionError("%r not found in warning list" % cls) 
- 
+        """Pop the first recorded warning, raise exception if not exists."""
+        for i, w in enumerate(self._list):
+            if issubclass(w.category, cls):
+                return self._list.pop(i)
+        __tracebackhide__ = True
+        raise AssertionError("%r not found in warning list" % cls)
+
     def clear(self) -> None:
-        """Clear the list of recorded warnings.""" 
-        self._list[:] = [] 
- 
+        """Clear the list of recorded warnings."""
+        self._list[:] = []
+
     # Type ignored because it doesn't exactly warnings.catch_warnings.__enter__
     # -- it returns a List but we only emulate one.
     def __enter__(self) -> "WarningsRecorder":  # type: ignore
-        if self._entered: 
-            __tracebackhide__ = True 
-            raise RuntimeError("Cannot enter %r twice" % self) 
+        if self._entered:
+            __tracebackhide__ = True
+            raise RuntimeError("Cannot enter %r twice" % self)
         _list = super().__enter__()
         # record=True means it's None.
         assert _list is not None
         self._list = _list
-        warnings.simplefilter("always") 
-        return self 
- 
+        warnings.simplefilter("always")
+        return self
+
     def __exit__(
         self,
         exc_type: Optional[Type[BaseException]],
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType],
     ) -> None:
-        if not self._entered: 
-            __tracebackhide__ = True 
-            raise RuntimeError("Cannot exit %r without entering first" % self) 
- 
+        if not self._entered:
+            __tracebackhide__ = True
+            raise RuntimeError("Cannot exit %r without entering first" % self)
+
         super().__exit__(exc_type, exc_val, exc_tb)
 
         # Built-in catch_warnings does not reset entered state so we do it
         # manually here for this context manager to become reusable.
         self._entered = False
- 
+
 
 @final
-class WarningsChecker(WarningsRecorder): 
+class WarningsChecker(WarningsRecorder):
     def __init__(
         self,
         expected_warning: Optional[
@@ -241,23 +241,23 @@ class WarningsChecker(WarningsRecorder):
     ) -> None:
         check_ispytest(_ispytest)
         super().__init__(_ispytest=True)
- 
+
         msg = "exceptions must be derived from Warning, not %s"
         if expected_warning is None:
             expected_warning_tup = None
         elif isinstance(expected_warning, tuple):
-            for exc in expected_warning: 
+            for exc in expected_warning:
                 if not issubclass(exc, Warning):
-                    raise TypeError(msg % type(exc)) 
+                    raise TypeError(msg % type(exc))
             expected_warning_tup = expected_warning
         elif issubclass(expected_warning, Warning):
             expected_warning_tup = (expected_warning,)
         else:
-            raise TypeError(msg % type(expected_warning)) 
- 
+            raise TypeError(msg % type(expected_warning))
+
         self.expected_warning = expected_warning_tup
-        self.match_expr = match_expr 
- 
+        self.match_expr = match_expr
+
     def __exit__(
         self,
         exc_type: Optional[Type[BaseException]],
@@ -265,32 +265,32 @@ class WarningsChecker(WarningsRecorder):
         exc_tb: Optional[TracebackType],
     ) -> None:
         super().__exit__(exc_type, exc_val, exc_tb)
- 
-        __tracebackhide__ = True 
- 
-        # only check if we're not currently handling an exception 
+
+        __tracebackhide__ = True
+
+        # only check if we're not currently handling an exception
         if exc_type is None and exc_val is None and exc_tb is None:
-            if self.expected_warning is not None: 
-                if not any(issubclass(r.category, self.expected_warning) for r in self): 
-                    __tracebackhide__ = True 
-                    fail( 
-                        "DID NOT WARN. No warnings of type {} was emitted. " 
-                        "The list of emitted warnings is: {}.".format( 
-                            self.expected_warning, [each.message for each in self] 
-                        ) 
-                    ) 
-                elif self.match_expr is not None: 
-                    for r in self: 
-                        if issubclass(r.category, self.expected_warning): 
-                            if re.compile(self.match_expr).search(str(r.message)): 
-                                break 
-                    else: 
-                        fail( 
-                            "DID NOT WARN. No warnings of type {} matching" 
-                            " ('{}') was emitted. The list of emitted warnings" 
-                            " is: {}.".format( 
-                                self.expected_warning, 
-                                self.match_expr, 
-                                [each.message for each in self], 
-                            ) 
-                        ) 
+            if self.expected_warning is not None:
+                if not any(issubclass(r.category, self.expected_warning) for r in self):
+                    __tracebackhide__ = True
+                    fail(
+                        "DID NOT WARN. No warnings of type {} was emitted. "
+                        "The list of emitted warnings is: {}.".format(
+                            self.expected_warning, [each.message for each in self]
+                        )
+                    )
+                elif self.match_expr is not None:
+                    for r in self:
+                        if issubclass(r.category, self.expected_warning):
+                            if re.compile(self.match_expr).search(str(r.message)):
+                                break
+                    else:
+                        fail(
+                            "DID NOT WARN. No warnings of type {} matching"
+                            " ('{}') was emitted. The list of emitted warnings"
+                            " is: {}.".format(
+                                self.expected_warning,
+                                self.match_expr,
+                                [each.message for each in self],
+                            )
+                        )