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

1 files changed, 110 insertions, 110 deletions

diff --git a/contrib/python/attrs/attr/validators.py b/contrib/python/attrs/attr/validators.py
index 22b741be17..b9a73054e9 100644
--- a/contrib/python/attrs/attr/validators.py
+++ b/contrib/python/attrs/attr/validators.py
@@ -4,23 +4,23 @@ Commonly useful validators.
 
 from __future__ import absolute_import, division, print_function
 
-import re 
- 
+import re
+
 from ._make import _AndValidator, and_, attrib, attrs
-from .exceptions import NotCallableError 
+from .exceptions import NotCallableError
 
 
-__all__ = [ 
-    "and_", 
-    "deep_iterable", 
-    "deep_mapping", 
-    "in_", 
-    "instance_of", 
-    "is_callable", 
-    "matches_re", 
-    "optional", 
-    "provides", 
-] 
+__all__ = [
+    "and_",
+    "deep_iterable",
+    "deep_mapping",
+    "in_",
+    "instance_of",
+    "is_callable",
+    "matches_re",
+    "optional",
+    "provides",
+]
 
 
 @attrs(repr=False, slots=True, hash=True)
@@ -53,92 +53,92 @@ class _InstanceOfValidator(object):
 
 def instance_of(type):
     """
-    A validator that raises a `TypeError` if the initializer is called 
+    A validator that raises a `TypeError` if the initializer is called
     with a wrong type for this particular attribute (checks are performed using
-    `isinstance` therefore it's also valid to pass a tuple of types). 
+    `isinstance` therefore it's also valid to pass a tuple of types).
 
     :param type: The type to check for.
     :type type: type or tuple of types
 
     :raises TypeError: With a human readable error message, the attribute
-        (of type `attr.Attribute`), the expected type, and the value it 
+        (of type `attr.Attribute`), the expected type, and the value it
         got.
     """
     return _InstanceOfValidator(type)
 
 
 @attrs(repr=False, frozen=True, slots=True)
-class _MatchesReValidator(object): 
-    regex = attrib() 
-    flags = attrib() 
-    match_func = attrib() 
- 
-    def __call__(self, inst, attr, value): 
-        """ 
-        We use a callable class to be able to change the ``__repr__``. 
-        """ 
-        if not self.match_func(value): 
-            raise ValueError( 
-                "'{name}' must match regex {regex!r}" 
-                " ({value!r} doesn't)".format( 
-                    name=attr.name, regex=self.regex.pattern, value=value 
-                ), 
-                attr, 
-                self.regex, 
-                value, 
-            ) 
- 
-    def __repr__(self): 
-        return "<matches_re validator for pattern {regex!r}>".format( 
-            regex=self.regex 
-        ) 
- 
- 
-def matches_re(regex, flags=0, func=None): 
-    r""" 
-    A validator that raises `ValueError` if the initializer is called 
-    with a string that doesn't match *regex*. 
- 
-    :param str regex: a regex string to match against 
-    :param int flags: flags that will be passed to the underlying re function 
-        (default 0) 
-    :param callable func: which underlying `re` function to call (options 
-        are `re.fullmatch`, `re.search`, `re.match`, default 
-        is ``None`` which means either `re.fullmatch` or an emulation of 
-        it on Python 2). For performance reasons, they won't be used directly 
-        but on a pre-`re.compile`\ ed pattern. 
- 
-    .. versionadded:: 19.2.0 
-    """ 
-    fullmatch = getattr(re, "fullmatch", None) 
-    valid_funcs = (fullmatch, None, re.search, re.match) 
-    if func not in valid_funcs: 
-        raise ValueError( 
-            "'func' must be one of %s." 
-            % ( 
-                ", ".join( 
-                    sorted( 
-                        e and e.__name__ or "None" for e in set(valid_funcs) 
-                    ) 
-                ), 
-            ) 
-        ) 
- 
-    pattern = re.compile(regex, flags) 
-    if func is re.match: 
-        match_func = pattern.match 
-    elif func is re.search: 
-        match_func = pattern.search 
-    else: 
-        if fullmatch: 
-            match_func = pattern.fullmatch 
-        else: 
-            pattern = re.compile(r"(?:{})\Z".format(regex), flags) 
-            match_func = pattern.match 
- 
-    return _MatchesReValidator(pattern, flags, match_func) 
- 
- 
+class _MatchesReValidator(object):
+    regex = attrib()
+    flags = attrib()
+    match_func = attrib()
+
+    def __call__(self, inst, attr, value):
+        """
+        We use a callable class to be able to change the ``__repr__``.
+        """
+        if not self.match_func(value):
+            raise ValueError(
+                "'{name}' must match regex {regex!r}"
+                " ({value!r} doesn't)".format(
+                    name=attr.name, regex=self.regex.pattern, value=value
+                ),
+                attr,
+                self.regex,
+                value,
+            )
+
+    def __repr__(self):
+        return "<matches_re validator for pattern {regex!r}>".format(
+            regex=self.regex
+        )
+
+
+def matches_re(regex, flags=0, func=None):
+    r"""
+    A validator that raises `ValueError` if the initializer is called
+    with a string that doesn't match *regex*.
+
+    :param str regex: a regex string to match against
+    :param int flags: flags that will be passed to the underlying re function
+        (default 0)
+    :param callable func: which underlying `re` function to call (options
+        are `re.fullmatch`, `re.search`, `re.match`, default
+        is ``None`` which means either `re.fullmatch` or an emulation of
+        it on Python 2). For performance reasons, they won't be used directly
+        but on a pre-`re.compile`\ ed pattern.
+
+    .. versionadded:: 19.2.0
+    """
+    fullmatch = getattr(re, "fullmatch", None)
+    valid_funcs = (fullmatch, None, re.search, re.match)
+    if func not in valid_funcs:
+        raise ValueError(
+            "'func' must be one of %s."
+            % (
+                ", ".join(
+                    sorted(
+                        e and e.__name__ or "None" for e in set(valid_funcs)
+                    )
+                ),
+            )
+        )
+
+    pattern = re.compile(regex, flags)
+    if func is re.match:
+        match_func = pattern.match
+    elif func is re.search:
+        match_func = pattern.search
+    else:
+        if fullmatch:
+            match_func = pattern.fullmatch
+        else:
+            pattern = re.compile(r"(?:{})\Z".format(regex), flags)
+            match_func = pattern.match
+
+    return _MatchesReValidator(pattern, flags, match_func)
+
+
 @attrs(repr=False, slots=True, hash=True)
 class _ProvidesValidator(object):
     interface = attrib()
@@ -166,7 +166,7 @@ class _ProvidesValidator(object):
 
 def provides(interface):
     """
-    A validator that raises a `TypeError` if the initializer is called 
+    A validator that raises a `TypeError` if the initializer is called
     with an object that does not provide the requested *interface* (checks are
     performed using ``interface.providedBy(value)`` (see `zope.interface
     <https://zopeinterface.readthedocs.io/en/latest/>`_).
@@ -175,7 +175,7 @@ def provides(interface):
     :type interface: ``zope.interface.Interface``
 
     :raises TypeError: With a human readable error message, the attribute
-        (of type `attr.Attribute`), the expected interface, and the 
+        (of type `attr.Attribute`), the expected interface, and the
         value it got.
     """
     return _ProvidesValidator(interface)
@@ -205,7 +205,7 @@ def optional(validator):
 
     :param validator: A validator (or a list of validators) that is used for
         non-``None`` values.
-    :type validator: callable or `list` of callables. 
+    :type validator: callable or `list` of callables.
 
     .. versionadded:: 15.1.0
     .. versionchanged:: 17.1.0 *validator* can be a list of validators.
@@ -240,15 +240,15 @@ class _InValidator(object):
 
 def in_(options):
     """
-    A validator that raises a `ValueError` if the initializer is called 
+    A validator that raises a `ValueError` if the initializer is called
     with a value that does not belong in the options provided.  The check is
     performed using ``value in options``.
 
     :param options: Allowed options.
-    :type options: list, tuple, `enum.Enum`, ... 
+    :type options: list, tuple, `enum.Enum`, ...
 
     :raises ValueError: With a human readable error message, the attribute (of
-       type `attr.Attribute`), the expected options, and the value it 
+       type `attr.Attribute`), the expected options, and the value it
        got.
 
     .. versionadded:: 17.1.0
@@ -263,16 +263,16 @@ class _IsCallableValidator(object):
         We use a callable class to be able to change the ``__repr__``.
         """
         if not callable(value):
-            message = ( 
-                "'{name}' must be callable " 
-                "(got {value!r} that is a {actual!r})." 
-            ) 
-            raise NotCallableError( 
-                msg=message.format( 
-                    name=attr.name, value=value, actual=value.__class__ 
-                ), 
-                value=value, 
-            ) 
+            message = (
+                "'{name}' must be callable "
+                "(got {value!r} that is a {actual!r})."
+            )
+            raise NotCallableError(
+                msg=message.format(
+                    name=attr.name, value=value, actual=value.__class__
+                ),
+                value=value,
+            )
 
     def __repr__(self):
         return "<is_callable validator>"
@@ -280,15 +280,15 @@ class _IsCallableValidator(object):
 
 def is_callable():
     """
-    A validator that raises a `attr.exceptions.NotCallableError` if the 
-    initializer is called with a value for this particular attribute 
-    that is not callable. 
+    A validator that raises a `attr.exceptions.NotCallableError` if the
+    initializer is called with a value for this particular attribute
+    that is not callable.
 
     .. versionadded:: 19.1.0
 
-    :raises `attr.exceptions.NotCallableError`: With a human readable error 
-        message containing the attribute (`attr.Attribute`) name, 
-        and the value it got. 
+    :raises `attr.exceptions.NotCallableError`: With a human readable error
+        message containing the attribute (`attr.Attribute`) name,
+        and the value it got.
     """
     return _IsCallableValidator()