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

18 files changed, 2723 insertions, 2723 deletions

diff --git a/contrib/python/packaging/py2/packaging/__init__.py b/contrib/python/packaging/py2/packaging/__init__.py
index a0cf67df52..8f8592ac60 100644
--- a/contrib/python/packaging/py2/packaging/__init__.py
+++ b/contrib/python/packaging/py2/packaging/__init__.py
@@ -1,6 +1,6 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
 from __future__ import absolute_import, division, print_function
 
 from .__about__ import (
diff --git a/contrib/python/packaging/py2/packaging/_compat.py b/contrib/python/packaging/py2/packaging/_compat.py
index e54bd4ede8..6be0ce31ad 100644
--- a/contrib/python/packaging/py2/packaging/_compat.py
+++ b/contrib/python/packaging/py2/packaging/_compat.py
@@ -1,38 +1,38 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import sys
-
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import sys 
+ 
 from ._typing import TYPE_CHECKING
-
+ 
 if TYPE_CHECKING:  # pragma: no cover
     from typing import Any, Dict, Tuple, Type
 
 
-PY2 = sys.version_info[0] == 2
-PY3 = sys.version_info[0] == 3
-
-# flake8: noqa
-
-if PY3:
+PY2 = sys.version_info[0] == 2 
+PY3 = sys.version_info[0] == 3 
+ 
+# flake8: noqa 
+ 
+if PY3: 
     string_types = (str,)
-else:
+else: 
     string_types = (basestring,)
-
-
-def with_metaclass(meta, *bases):
+ 
+ 
+def with_metaclass(meta, *bases): 
     # type: (Type[Any], Tuple[Type[Any], ...]) -> Any
-    """
-    Create a base class with a metaclass.
-    """
-    # This requires a bit of explanation: the basic idea is to make a dummy
-    # metaclass for one level of class instantiation that replaces itself with
-    # the actual metaclass.
+    """ 
+    Create a base class with a metaclass. 
+    """ 
+    # This requires a bit of explanation: the basic idea is to make a dummy 
+    # metaclass for one level of class instantiation that replaces itself with 
+    # the actual metaclass. 
     class metaclass(meta):  # type: ignore
-        def __new__(cls, name, this_bases, d):
+        def __new__(cls, name, this_bases, d): 
             # type: (Type[Any], str, Tuple[Any], Dict[Any, Any]) -> Any
-            return meta(name, bases, d)
+            return meta(name, bases, d) 
 
     return type.__new__(metaclass, "temporary_class", (), {})
diff --git a/contrib/python/packaging/py2/packaging/_structures.py b/contrib/python/packaging/py2/packaging/_structures.py
index 800d5c5588..cade21bd4b 100644
--- a/contrib/python/packaging/py2/packaging/_structures.py
+++ b/contrib/python/packaging/py2/packaging/_structures.py
@@ -1,86 +1,86 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+ 
 class InfinityType(object):
-    def __repr__(self):
+    def __repr__(self): 
         # type: () -> str
-        return "Infinity"
-
-    def __hash__(self):
+        return "Infinity" 
+ 
+    def __hash__(self): 
         # type: () -> int
-        return hash(repr(self))
-
-    def __lt__(self, other):
+        return hash(repr(self)) 
+ 
+    def __lt__(self, other): 
         # type: (object) -> bool
-        return False
-
-    def __le__(self, other):
+        return False 
+ 
+    def __le__(self, other): 
         # type: (object) -> bool
-        return False
-
-    def __eq__(self, other):
+        return False 
+ 
+    def __eq__(self, other): 
         # type: (object) -> bool
-        return isinstance(other, self.__class__)
-
-    def __ne__(self, other):
+        return isinstance(other, self.__class__) 
+ 
+    def __ne__(self, other): 
         # type: (object) -> bool
-        return not isinstance(other, self.__class__)
-
-    def __gt__(self, other):
+        return not isinstance(other, self.__class__) 
+ 
+    def __gt__(self, other): 
         # type: (object) -> bool
-        return True
-
-    def __ge__(self, other):
+        return True 
+ 
+    def __ge__(self, other): 
         # type: (object) -> bool
-        return True
-
-    def __neg__(self):
+        return True 
+ 
+    def __neg__(self): 
         # type: (object) -> NegativeInfinityType
-        return NegativeInfinity
-
+        return NegativeInfinity 
+ 
 
 Infinity = InfinityType()
-
-
+ 
+ 
 class NegativeInfinityType(object):
-    def __repr__(self):
+    def __repr__(self): 
         # type: () -> str
-        return "-Infinity"
-
-    def __hash__(self):
+        return "-Infinity" 
+ 
+    def __hash__(self): 
         # type: () -> int
-        return hash(repr(self))
-
-    def __lt__(self, other):
+        return hash(repr(self)) 
+ 
+    def __lt__(self, other): 
         # type: (object) -> bool
-        return True
-
-    def __le__(self, other):
+        return True 
+ 
+    def __le__(self, other): 
         # type: (object) -> bool
-        return True
-
-    def __eq__(self, other):
+        return True 
+ 
+    def __eq__(self, other): 
         # type: (object) -> bool
-        return isinstance(other, self.__class__)
-
-    def __ne__(self, other):
+        return isinstance(other, self.__class__) 
+ 
+    def __ne__(self, other): 
         # type: (object) -> bool
-        return not isinstance(other, self.__class__)
-
-    def __gt__(self, other):
+        return not isinstance(other, self.__class__) 
+ 
+    def __gt__(self, other): 
         # type: (object) -> bool
-        return False
-
-    def __ge__(self, other):
+        return False 
+ 
+    def __ge__(self, other): 
         # type: (object) -> bool
-        return False
-
-    def __neg__(self):
+        return False 
+ 
+    def __neg__(self): 
         # type: (object) -> InfinityType
-        return Infinity
-
+        return Infinity 
+ 
 
 NegativeInfinity = NegativeInfinityType()
diff --git a/contrib/python/packaging/py2/packaging/markers.py b/contrib/python/packaging/py2/packaging/markers.py
index e0330ab6ab..1d711d99ee 100644
--- a/contrib/python/packaging/py2/packaging/markers.py
+++ b/contrib/python/packaging/py2/packaging/markers.py
@@ -1,13 +1,13 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import operator
-import os
-import platform
-import sys
-
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import operator 
+import os 
+import platform 
+import sys 
+ 
 from pyparsing import (  # noqa: N817
     Forward,
     Group,
@@ -19,82 +19,82 @@ from pyparsing import (  # noqa: N817
     stringEnd,
     stringStart,
 )
-
-from ._compat import string_types
+ 
+from ._compat import string_types 
 from ._typing import TYPE_CHECKING
 from .specifiers import InvalidSpecifier, Specifier
-
+ 
 if TYPE_CHECKING:  # pragma: no cover
     from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-
+ 
     Operator = Callable[[str, str], bool]
 
 
-__all__ = [
+__all__ = [ 
     "InvalidMarker",
     "UndefinedComparison",
     "UndefinedEnvironmentName",
     "Marker",
     "default_environment",
-]
-
-
-class InvalidMarker(ValueError):
-    """
-    An invalid marker was found, users should refer to PEP 508.
-    """
-
-
-class UndefinedComparison(ValueError):
-    """
-    An invalid operation was attempted on a value that doesn't support it.
-    """
-
-
-class UndefinedEnvironmentName(ValueError):
-    """
-    A name was attempted to be used that does not exist inside of the
-    environment.
-    """
-
-
-class Node(object):
-    def __init__(self, value):
+] 
+ 
+ 
+class InvalidMarker(ValueError): 
+    """ 
+    An invalid marker was found, users should refer to PEP 508. 
+    """ 
+ 
+ 
+class UndefinedComparison(ValueError): 
+    """ 
+    An invalid operation was attempted on a value that doesn't support it. 
+    """ 
+ 
+ 
+class UndefinedEnvironmentName(ValueError): 
+    """ 
+    A name was attempted to be used that does not exist inside of the 
+    environment. 
+    """ 
+ 
+ 
+class Node(object): 
+    def __init__(self, value): 
         # type: (Any) -> None
-        self.value = value
-
-    def __str__(self):
+        self.value = value 
+ 
+    def __str__(self): 
         # type: () -> str
-        return str(self.value)
-
-    def __repr__(self):
+        return str(self.value) 
+ 
+    def __repr__(self): 
         # type: () -> str
-        return "<{0}({1!r})>".format(self.__class__.__name__, str(self))
-
-    def serialize(self):
+        return "<{0}({1!r})>".format(self.__class__.__name__, str(self)) 
+ 
+    def serialize(self): 
         # type: () -> str
-        raise NotImplementedError
-
-
-class Variable(Node):
-    def serialize(self):
+        raise NotImplementedError 
+ 
+ 
+class Variable(Node): 
+    def serialize(self): 
         # type: () -> str
-        return str(self)
-
-
-class Value(Node):
-    def serialize(self):
+        return str(self) 
+ 
+ 
+class Value(Node): 
+    def serialize(self): 
         # type: () -> str
-        return '"{0}"'.format(self)
-
-
-class Op(Node):
-    def serialize(self):
+        return '"{0}"'.format(self) 
+ 
+ 
+class Op(Node): 
+    def serialize(self): 
         # type: () -> str
-        return str(self)
-
-
-VARIABLE = (
+        return str(self) 
+ 
+ 
+VARIABLE = ( 
     L("implementation_version")
     | L("platform_python_implementation")
     | L("implementation_name")
@@ -113,167 +113,167 @@ VARIABLE = (
     | L("platform.python_implementation")  # PEP-345
     | L("python_implementation")  # undocumented setuptools legacy
     | L("extra")  # PEP-508
-)
-ALIASES = {
+) 
+ALIASES = { 
     "os.name": "os_name",
     "sys.platform": "sys_platform",
     "platform.version": "platform_version",
     "platform.machine": "platform_machine",
     "platform.python_implementation": "platform_python_implementation",
     "python_implementation": "platform_python_implementation",
-}
-VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))
-
-VERSION_CMP = (
+} 
+VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0]))) 
+ 
+VERSION_CMP = ( 
     L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<")
-)
-
-MARKER_OP = VERSION_CMP | L("not in") | L("in")
-MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))
-
-MARKER_VALUE = QuotedString("'") | QuotedString('"')
-MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
-
-BOOLOP = L("and") | L("or")
-
-MARKER_VAR = VARIABLE | MARKER_VALUE
-
-MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
-MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
-
-LPAREN = L("(").suppress()
-RPAREN = L(")").suppress()
-
-MARKER_EXPR = Forward()
-MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
-MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
-
-MARKER = stringStart + MARKER_EXPR + stringEnd
-
-
-def _coerce_parse_result(results):
+) 
+ 
+MARKER_OP = VERSION_CMP | L("not in") | L("in") 
+MARKER_OP.setParseAction(lambda s, l, t: Op(t[0])) 
+ 
+MARKER_VALUE = QuotedString("'") | QuotedString('"') 
+MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0])) 
+ 
+BOOLOP = L("and") | L("or") 
+ 
+MARKER_VAR = VARIABLE | MARKER_VALUE 
+ 
+MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR) 
+MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0])) 
+ 
+LPAREN = L("(").suppress() 
+RPAREN = L(")").suppress() 
+ 
+MARKER_EXPR = Forward() 
+MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN) 
+MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR) 
+ 
+MARKER = stringStart + MARKER_EXPR + stringEnd 
+ 
+ 
+def _coerce_parse_result(results): 
     # type: (Union[ParseResults, List[Any]]) -> List[Any]
-    if isinstance(results, ParseResults):
-        return [_coerce_parse_result(i) for i in results]
-    else:
-        return results
-
-
-def _format_marker(marker, first=True):
+    if isinstance(results, ParseResults): 
+        return [_coerce_parse_result(i) for i in results] 
+    else: 
+        return results 
+ 
+ 
+def _format_marker(marker, first=True): 
     # type: (Union[List[str], Tuple[Node, ...], str], Optional[bool]) -> str
 
-    assert isinstance(marker, (list, tuple, string_types))
-
-    # Sometimes we have a structure like [[...]] which is a single item list
-    # where the single item is itself it's own list. In that case we want skip
-    # the rest of this function so that we don't get extraneous () on the
-    # outside.
+    assert isinstance(marker, (list, tuple, string_types)) 
+ 
+    # Sometimes we have a structure like [[...]] which is a single item list 
+    # where the single item is itself it's own list. In that case we want skip 
+    # the rest of this function so that we don't get extraneous () on the 
+    # outside. 
     if (
         isinstance(marker, list)
         and len(marker) == 1
         and isinstance(marker[0], (list, tuple))
     ):
-        return _format_marker(marker[0])
-
-    if isinstance(marker, list):
-        inner = (_format_marker(m, first=False) for m in marker)
-        if first:
-            return " ".join(inner)
-        else:
-            return "(" + " ".join(inner) + ")"
-    elif isinstance(marker, tuple):
-        return " ".join([m.serialize() for m in marker])
-    else:
-        return marker
-
-
-_operators = {
-    "in": lambda lhs, rhs: lhs in rhs,
-    "not in": lambda lhs, rhs: lhs not in rhs,
-    "<": operator.lt,
-    "<=": operator.le,
-    "==": operator.eq,
-    "!=": operator.ne,
-    ">=": operator.ge,
-    ">": operator.gt,
+        return _format_marker(marker[0]) 
+ 
+    if isinstance(marker, list): 
+        inner = (_format_marker(m, first=False) for m in marker) 
+        if first: 
+            return " ".join(inner) 
+        else: 
+            return "(" + " ".join(inner) + ")" 
+    elif isinstance(marker, tuple): 
+        return " ".join([m.serialize() for m in marker]) 
+    else: 
+        return marker 
+ 
+ 
+_operators = { 
+    "in": lambda lhs, rhs: lhs in rhs, 
+    "not in": lambda lhs, rhs: lhs not in rhs, 
+    "<": operator.lt, 
+    "<=": operator.le, 
+    "==": operator.eq, 
+    "!=": operator.ne, 
+    ">=": operator.ge, 
+    ">": operator.gt, 
 }  # type: Dict[str, Operator]
-
-
-def _eval_op(lhs, op, rhs):
+ 
+ 
+def _eval_op(lhs, op, rhs): 
     # type: (str, Op, str) -> bool
-    try:
-        spec = Specifier("".join([op.serialize(), rhs]))
-    except InvalidSpecifier:
-        pass
-    else:
-        return spec.contains(lhs)
-
+    try: 
+        spec = Specifier("".join([op.serialize(), rhs])) 
+    except InvalidSpecifier: 
+        pass 
+    else: 
+        return spec.contains(lhs) 
+ 
     oper = _operators.get(op.serialize())  # type: Optional[Operator]
-    if oper is None:
-        raise UndefinedComparison(
-            "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs)
-        )
-
-    return oper(lhs, rhs)
-
-
+    if oper is None: 
+        raise UndefinedComparison( 
+            "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs) 
+        ) 
+ 
+    return oper(lhs, rhs) 
+ 
+ 
 class Undefined(object):
     pass
-
-
+ 
+ 
 _undefined = Undefined()
 
 
-def _get_env(environment, name):
+def _get_env(environment, name): 
     # type: (Dict[str, str], str) -> str
     value = environment.get(name, _undefined)  # type: Union[str, Undefined]
-
+ 
     if isinstance(value, Undefined):
-        raise UndefinedEnvironmentName(
-            "{0!r} does not exist in evaluation environment.".format(name)
-        )
-
-    return value
-
-
-def _evaluate_markers(markers, environment):
+        raise UndefinedEnvironmentName( 
+            "{0!r} does not exist in evaluation environment.".format(name) 
+        ) 
+ 
+    return value 
+ 
+ 
+def _evaluate_markers(markers, environment): 
     # type: (List[Any], Dict[str, str]) -> bool
     groups = [[]]  # type: List[List[bool]]
-
-    for marker in markers:
-        assert isinstance(marker, (list, tuple, string_types))
-
-        if isinstance(marker, list):
-            groups[-1].append(_evaluate_markers(marker, environment))
-        elif isinstance(marker, tuple):
-            lhs, op, rhs = marker
-
-            if isinstance(lhs, Variable):
-                lhs_value = _get_env(environment, lhs.value)
-                rhs_value = rhs.value
-            else:
-                lhs_value = lhs.value
-                rhs_value = _get_env(environment, rhs.value)
-
-            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
-        else:
-            assert marker in ["and", "or"]
-            if marker == "or":
-                groups.append([])
-
-    return any(all(item) for item in groups)
-
-
-def format_full_version(info):
+ 
+    for marker in markers: 
+        assert isinstance(marker, (list, tuple, string_types)) 
+ 
+        if isinstance(marker, list): 
+            groups[-1].append(_evaluate_markers(marker, environment)) 
+        elif isinstance(marker, tuple): 
+            lhs, op, rhs = marker 
+ 
+            if isinstance(lhs, Variable): 
+                lhs_value = _get_env(environment, lhs.value) 
+                rhs_value = rhs.value 
+            else: 
+                lhs_value = lhs.value 
+                rhs_value = _get_env(environment, rhs.value) 
+ 
+            groups[-1].append(_eval_op(lhs_value, op, rhs_value)) 
+        else: 
+            assert marker in ["and", "or"] 
+            if marker == "or": 
+                groups.append([]) 
+ 
+    return any(all(item) for item in groups) 
+ 
+ 
+def format_full_version(info): 
     # type: (sys._version_info) -> str
     version = "{0.major}.{0.minor}.{0.micro}".format(info)
-    kind = info.releaselevel
+    kind = info.releaselevel 
     if kind != "final":
-        version += kind[0] + str(info.serial)
-    return version
-
-
-def default_environment():
+        version += kind[0] + str(info.serial) 
+    return version 
+ 
+ 
+def default_environment(): 
     # type: () -> Dict[str, str]
     if hasattr(sys, "implementation"):
         # Ignoring the `sys.implementation` reference for type checking due to
@@ -281,56 +281,56 @@ def default_environment():
         # run with the `--py27` flag.
         iver = format_full_version(sys.implementation.version)  # type: ignore
         implementation_name = sys.implementation.name  # type: ignore
-    else:
+    else: 
         iver = "0"
         implementation_name = ""
-
-    return {
-        "implementation_name": implementation_name,
-        "implementation_version": iver,
-        "os_name": os.name,
-        "platform_machine": platform.machine(),
-        "platform_release": platform.release(),
-        "platform_system": platform.system(),
-        "platform_version": platform.version(),
-        "python_full_version": platform.python_version(),
-        "platform_python_implementation": platform.python_implementation(),
+ 
+    return { 
+        "implementation_name": implementation_name, 
+        "implementation_version": iver, 
+        "os_name": os.name, 
+        "platform_machine": platform.machine(), 
+        "platform_release": platform.release(), 
+        "platform_system": platform.system(), 
+        "platform_version": platform.version(), 
+        "python_full_version": platform.python_version(), 
+        "platform_python_implementation": platform.python_implementation(), 
         "python_version": ".".join(platform.python_version_tuple()[:2]),
-        "sys_platform": sys.platform,
-    }
-
-
-class Marker(object):
-    def __init__(self, marker):
+        "sys_platform": sys.platform, 
+    } 
+ 
+ 
+class Marker(object): 
+    def __init__(self, marker): 
         # type: (str) -> None
-        try:
-            self._markers = _coerce_parse_result(MARKER.parseString(marker))
-        except ParseException as e:
-            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format(
+        try: 
+            self._markers = _coerce_parse_result(MARKER.parseString(marker)) 
+        except ParseException as e: 
+            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format( 
                 marker, marker[e.loc : e.loc + 8]
             )
-            raise InvalidMarker(err_str)
-
-    def __str__(self):
+            raise InvalidMarker(err_str) 
+ 
+    def __str__(self): 
         # type: () -> str
-        return _format_marker(self._markers)
-
-    def __repr__(self):
+        return _format_marker(self._markers) 
+ 
+    def __repr__(self): 
         # type: () -> str
-        return "<Marker({0!r})>".format(str(self))
-
-    def evaluate(self, environment=None):
+        return "<Marker({0!r})>".format(str(self)) 
+ 
+    def evaluate(self, environment=None): 
         # type: (Optional[Dict[str, str]]) -> bool
-        """Evaluate a marker.
-
-        Return the boolean from evaluating the given marker against the
-        environment. environment is an optional argument to override all or
-        part of the determined environment.
-
-        The environment is determined from the current Python process.
-        """
-        current_environment = default_environment()
-        if environment is not None:
-            current_environment.update(environment)
-
-        return _evaluate_markers(self._markers, current_environment)
+        """Evaluate a marker. 
+ 
+        Return the boolean from evaluating the given marker against the 
+        environment. environment is an optional argument to override all or 
+        part of the determined environment. 
+ 
+        The environment is determined from the current Python process. 
+        """ 
+        current_environment = default_environment() 
+        if environment is not None: 
+            current_environment.update(environment) 
+ 
+        return _evaluate_markers(self._markers, current_environment) 
diff --git a/contrib/python/packaging/py2/packaging/requirements.py b/contrib/python/packaging/py2/packaging/requirements.py
index aa69d50d1a..36ed88223d 100644
--- a/contrib/python/packaging/py2/packaging/requirements.py
+++ b/contrib/python/packaging/py2/packaging/requirements.py
@@ -1,12 +1,12 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
 import re
-import string
+import string 
 import sys
-
+ 
 from pyparsing import (  # noqa: N817
     Combine,
     Literal as L,
@@ -19,11 +19,11 @@ from pyparsing import (  # noqa: N817
     stringEnd,
     stringStart,
 )
-
+ 
 from ._typing import TYPE_CHECKING
-from .markers import MARKER_EXPR, Marker
-from .specifiers import LegacySpecifier, Specifier, SpecifierSet
-
+from .markers import MARKER_EXPR, Marker 
+from .specifiers import LegacySpecifier, Specifier, SpecifierSet 
+ 
 if sys.version_info[0] >= 3:
     from urllib import parse as urlparse  # pragma: no cover
 else:  # pragma: no cover
@@ -32,95 +32,95 @@ else:  # pragma: no cover
 
 if TYPE_CHECKING:  # pragma: no cover
     from typing import List, Optional as TOptional, Set
-
-
-class InvalidRequirement(ValueError):
-    """
-    An invalid requirement was found, users should refer to PEP 508.
-    """
-
-
-ALPHANUM = Word(string.ascii_letters + string.digits)
-
-LBRACKET = L("[").suppress()
-RBRACKET = L("]").suppress()
-LPAREN = L("(").suppress()
-RPAREN = L(")").suppress()
-COMMA = L(",").suppress()
-SEMICOLON = L(";").suppress()
-AT = L("@").suppress()
-
-PUNCTUATION = Word("-_.")
-IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
-IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
-
-NAME = IDENTIFIER("name")
-EXTRA = IDENTIFIER
-
+ 
+
+class InvalidRequirement(ValueError): 
+    """ 
+    An invalid requirement was found, users should refer to PEP 508. 
+    """ 
+ 
+ 
+ALPHANUM = Word(string.ascii_letters + string.digits) 
+ 
+LBRACKET = L("[").suppress() 
+RBRACKET = L("]").suppress() 
+LPAREN = L("(").suppress() 
+RPAREN = L(")").suppress() 
+COMMA = L(",").suppress() 
+SEMICOLON = L(";").suppress() 
+AT = L("@").suppress() 
+ 
+PUNCTUATION = Word("-_.") 
+IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM) 
+IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END)) 
+ 
+NAME = IDENTIFIER("name") 
+EXTRA = IDENTIFIER 
+ 
 URI = Regex(r"[^ ]+")("url")
 URL = AT + URI
-
-EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
-EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
-
-VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
-VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
-
-VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
+ 
+EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA) 
+EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras") 
+ 
+VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE) 
+VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE) 
+ 
+VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY 
 VERSION_MANY = Combine(
     VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False
 )("_raw_spec")
-_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY))
+_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY)) 
 _VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "")
-
-VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
-VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
-
-MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
-MARKER_EXPR.setParseAction(
+ 
+VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier") 
+VERSION_SPEC.setParseAction(lambda s, l, t: t[1]) 
+ 
+MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker") 
+MARKER_EXPR.setParseAction( 
     lambda s, l, t: Marker(s[t._original_start : t._original_end])
-)
+) 
 MARKER_SEPARATOR = SEMICOLON
 MARKER = MARKER_SEPARATOR + MARKER_EXPR
-
-VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
-URL_AND_MARKER = URL + Optional(MARKER)
-
+ 
+VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER) 
+URL_AND_MARKER = URL + Optional(MARKER) 
+ 
 NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
-
-REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
+ 
+REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd 
 # pyparsing isn't thread safe during initialization, so we do it eagerly, see
 # issue #104
 REQUIREMENT.parseString("x[]")
-
-
-class Requirement(object):
-    """Parse a requirement.
-
-    Parse a given requirement string into its parts, such as name, specifier,
-    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
-    string.
-    """
-
-    # TODO: Can we test whether something is contained within a requirement?
-    #       If so how do we do that? Do we need to test against the _name_ of
-    #       the thing as well as the version? What about the markers?
-    # TODO: Can we normalize the name and extra name?
-
-    def __init__(self, requirement_string):
+ 
+ 
+class Requirement(object): 
+    """Parse a requirement. 
+ 
+    Parse a given requirement string into its parts, such as name, specifier, 
+    URL, and extras. Raises InvalidRequirement on a badly-formed requirement 
+    string. 
+    """ 
+ 
+    # TODO: Can we test whether something is contained within a requirement? 
+    #       If so how do we do that? Do we need to test against the _name_ of 
+    #       the thing as well as the version? What about the markers? 
+    # TODO: Can we normalize the name and extra name? 
+ 
+    def __init__(self, requirement_string): 
         # type: (str) -> None
-        try:
-            req = REQUIREMENT.parseString(requirement_string)
-        except ParseException as e:
+        try: 
+            req = REQUIREMENT.parseString(requirement_string) 
+        except ParseException as e: 
             raise InvalidRequirement(
                 'Parse error at "{0!r}": {1}'.format(
                     requirement_string[e.loc : e.loc + 8], e.msg
                 )
             )
-
+ 
         self.name = req.name  # type: str
-        if req.url:
-            parsed_url = urlparse.urlparse(req.url)
+        if req.url: 
+            parsed_url = urlparse.urlparse(req.url) 
             if parsed_url.scheme == "file":
                 if urlparse.urlunparse(parsed_url) != req.url:
                     raise InvalidRequirement("Invalid URL given")
@@ -129,32 +129,32 @@ class Requirement(object):
             ):
                 raise InvalidRequirement("Invalid URL: {0}".format(req.url))
             self.url = req.url  # type: TOptional[str]
-        else:
-            self.url = None
+        else: 
+            self.url = None 
         self.extras = set(req.extras.asList() if req.extras else [])  # type: Set[str]
         self.specifier = SpecifierSet(req.specifier)  # type: SpecifierSet
         self.marker = req.marker if req.marker else None  # type: TOptional[Marker]
-
-    def __str__(self):
+ 
+    def __str__(self): 
         # type: () -> str
         parts = [self.name]  # type: List[str]
-
-        if self.extras:
-            parts.append("[{0}]".format(",".join(sorted(self.extras))))
-
-        if self.specifier:
-            parts.append(str(self.specifier))
-
-        if self.url:
-            parts.append("@ {0}".format(self.url))
+ 
+        if self.extras: 
+            parts.append("[{0}]".format(",".join(sorted(self.extras)))) 
+ 
+        if self.specifier: 
+            parts.append(str(self.specifier)) 
+ 
+        if self.url: 
+            parts.append("@ {0}".format(self.url)) 
             if self.marker:
                 parts.append(" ")
-
-        if self.marker:
-            parts.append("; {0}".format(self.marker))
-
-        return "".join(parts)
-
-    def __repr__(self):
+ 
+        if self.marker: 
+            parts.append("; {0}".format(self.marker)) 
+ 
+        return "".join(parts) 
+ 
+    def __repr__(self): 
         # type: () -> str
-        return "<Requirement({0!r})>".format(str(self))
+        return "<Requirement({0!r})>".format(str(self)) 
diff --git a/contrib/python/packaging/py2/packaging/specifiers.py b/contrib/python/packaging/py2/packaging/specifiers.py
index a6a83c1fe9..f0a52f3c6f 100644
--- a/contrib/python/packaging/py2/packaging/specifiers.py
+++ b/contrib/python/packaging/py2/packaging/specifiers.py
@@ -1,281 +1,281 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import abc
-import functools
-import itertools
-import re
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import abc 
+import functools 
+import itertools 
+import re 
 import warnings
-
-from ._compat import string_types, with_metaclass
+ 
+from ._compat import string_types, with_metaclass 
 from ._typing import TYPE_CHECKING
 from .utils import canonicalize_version
 from .version import LegacyVersion, Version, parse
-
+ 
 if TYPE_CHECKING:  # pragma: no cover
     from typing import Callable, Dict, Iterable, Iterator, List, Optional, Tuple, Union
-
+ 
     ParsedVersion = Union[Version, LegacyVersion]
     UnparsedVersion = Union[Version, LegacyVersion, str]
     CallableOperator = Callable[[ParsedVersion, str], bool]
 
 
-class InvalidSpecifier(ValueError):
-    """
-    An invalid specifier was found, users should refer to PEP 440.
-    """
-
-
+class InvalidSpecifier(ValueError): 
+    """ 
+    An invalid specifier was found, users should refer to PEP 440. 
+    """ 
+ 
+ 
 class BaseSpecifier(with_metaclass(abc.ABCMeta, object)):  # type: ignore
-    @abc.abstractmethod
-    def __str__(self):
+    @abc.abstractmethod 
+    def __str__(self): 
         # type: () -> str
-        """
-        Returns the str representation of this Specifier like object. This
-        should be representative of the Specifier itself.
-        """
-
-    @abc.abstractmethod
-    def __hash__(self):
+        """ 
+        Returns the str representation of this Specifier like object. This 
+        should be representative of the Specifier itself. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def __hash__(self): 
         # type: () -> int
-        """
-        Returns a hash value for this Specifier like object.
-        """
-
-    @abc.abstractmethod
-    def __eq__(self, other):
+        """ 
+        Returns a hash value for this Specifier like object. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def __eq__(self, other): 
         # type: (object) -> bool
-        """
-        Returns a boolean representing whether or not the two Specifier like
-        objects are equal.
-        """
-
-    @abc.abstractmethod
-    def __ne__(self, other):
+        """ 
+        Returns a boolean representing whether or not the two Specifier like 
+        objects are equal. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def __ne__(self, other): 
         # type: (object) -> bool
-        """
-        Returns a boolean representing whether or not the two Specifier like
-        objects are not equal.
-        """
-
-    @abc.abstractproperty
-    def prereleases(self):
+        """ 
+        Returns a boolean representing whether or not the two Specifier like 
+        objects are not equal. 
+        """ 
+ 
+    @abc.abstractproperty 
+    def prereleases(self): 
         # type: () -> Optional[bool]
-        """
-        Returns whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @prereleases.setter
-    def prereleases(self, value):
+        """ 
+        Returns whether or not pre-releases as a whole are allowed by this 
+        specifier. 
+        """ 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
         # type: (bool) -> None
-        """
-        Sets whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @abc.abstractmethod
-    def contains(self, item, prereleases=None):
+        """ 
+        Sets whether or not pre-releases as a whole are allowed by this 
+        specifier. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def contains(self, item, prereleases=None): 
         # type: (str, Optional[bool]) -> bool
-        """
-        Determines if the given item is contained within this specifier.
-        """
-
-    @abc.abstractmethod
-    def filter(self, iterable, prereleases=None):
+        """ 
+        Determines if the given item is contained within this specifier. 
+        """ 
+ 
+    @abc.abstractmethod 
+    def filter(self, iterable, prereleases=None): 
         # type: (Iterable[UnparsedVersion], Optional[bool]) -> Iterable[UnparsedVersion]
-        """
-        Takes an iterable of items and filters them so that only items which
-        are contained within this specifier are allowed in it.
-        """
-
-
-class _IndividualSpecifier(BaseSpecifier):
-
+        """ 
+        Takes an iterable of items and filters them so that only items which 
+        are contained within this specifier are allowed in it. 
+        """ 
+ 
+ 
+class _IndividualSpecifier(BaseSpecifier): 
+ 
     _operators = {}  # type: Dict[str, str]
-
-    def __init__(self, spec="", prereleases=None):
+ 
+    def __init__(self, spec="", prereleases=None): 
         # type: (str, Optional[bool]) -> None
-        match = self._regex.search(spec)
-        if not match:
-            raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec))
-
-        self._spec = (
-            match.group("operator").strip(),
-            match.group("version").strip(),
+        match = self._regex.search(spec) 
+        if not match: 
+            raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec)) 
+ 
+        self._spec = ( 
+            match.group("operator").strip(), 
+            match.group("version").strip(), 
         )  # type: Tuple[str, str]
-
-        # Store whether or not this Specifier should accept prereleases
-        self._prereleases = prereleases
-
-    def __repr__(self):
+ 
+        # Store whether or not this Specifier should accept prereleases 
+        self._prereleases = prereleases 
+ 
+    def __repr__(self): 
         # type: () -> str
-        pre = (
-            ", prereleases={0!r}".format(self.prereleases)
-            if self._prereleases is not None
-            else ""
-        )
-
+        pre = ( 
+            ", prereleases={0!r}".format(self.prereleases) 
+            if self._prereleases is not None 
+            else "" 
+        ) 
+ 
         return "<{0}({1!r}{2})>".format(self.__class__.__name__, str(self), pre)
-
-    def __str__(self):
+ 
+    def __str__(self): 
         # type: () -> str
-        return "{0}{1}".format(*self._spec)
-
+        return "{0}{1}".format(*self._spec) 
+ 
     @property
     def _canonical_spec(self):
         # type: () -> Tuple[str, Union[Version, str]]
         return self._spec[0], canonicalize_version(self._spec[1])
 
-    def __hash__(self):
+    def __hash__(self): 
         # type: () -> int
         return hash(self._canonical_spec)
-
-    def __eq__(self, other):
+ 
+    def __eq__(self, other): 
         # type: (object) -> bool
-        if isinstance(other, string_types):
-            try:
+        if isinstance(other, string_types): 
+            try: 
                 other = self.__class__(str(other))
-            except InvalidSpecifier:
-                return NotImplemented
-        elif not isinstance(other, self.__class__):
-            return NotImplemented
-
+            except InvalidSpecifier: 
+                return NotImplemented 
+        elif not isinstance(other, self.__class__): 
+            return NotImplemented 
+ 
         return self._canonical_spec == other._canonical_spec
-
-    def __ne__(self, other):
+ 
+    def __ne__(self, other): 
         # type: (object) -> bool
-        if isinstance(other, string_types):
-            try:
+        if isinstance(other, string_types): 
+            try: 
                 other = self.__class__(str(other))
-            except InvalidSpecifier:
-                return NotImplemented
-        elif not isinstance(other, self.__class__):
-            return NotImplemented
-
-        return self._spec != other._spec
-
-    def _get_operator(self, op):
+            except InvalidSpecifier: 
+                return NotImplemented 
+        elif not isinstance(other, self.__class__): 
+            return NotImplemented 
+ 
+        return self._spec != other._spec 
+ 
+    def _get_operator(self, op): 
         # type: (str) -> CallableOperator
         operator_callable = getattr(
             self, "_compare_{0}".format(self._operators[op])
         )  # type: CallableOperator
         return operator_callable
-
-    def _coerce_version(self, version):
+ 
+    def _coerce_version(self, version): 
         # type: (UnparsedVersion) -> ParsedVersion
-        if not isinstance(version, (LegacyVersion, Version)):
-            version = parse(version)
-        return version
-
-    @property
-    def operator(self):
+        if not isinstance(version, (LegacyVersion, Version)): 
+            version = parse(version) 
+        return version 
+ 
+    @property 
+    def operator(self): 
         # type: () -> str
-        return self._spec[0]
-
-    @property
-    def version(self):
+        return self._spec[0] 
+ 
+    @property 
+    def version(self): 
         # type: () -> str
-        return self._spec[1]
-
-    @property
-    def prereleases(self):
+        return self._spec[1] 
+ 
+    @property 
+    def prereleases(self): 
         # type: () -> Optional[bool]
-        return self._prereleases
-
-    @prereleases.setter
-    def prereleases(self, value):
+        return self._prereleases 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
         # type: (bool) -> None
-        self._prereleases = value
-
-    def __contains__(self, item):
+        self._prereleases = value 
+ 
+    def __contains__(self, item): 
         # type: (str) -> bool
-        return self.contains(item)
-
-    def contains(self, item, prereleases=None):
+        return self.contains(item) 
+ 
+    def contains(self, item, prereleases=None): 
         # type: (UnparsedVersion, Optional[bool]) -> bool
 
-        # Determine if prereleases are to be allowed or not.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # Normalize item to a Version or LegacyVersion, this allows us to have
-        # a shortcut for ``"2.0" in Specifier(">=2")
+        # Determine if prereleases are to be allowed or not. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # Normalize item to a Version or LegacyVersion, this allows us to have 
+        # a shortcut for ``"2.0" in Specifier(">=2") 
         normalized_item = self._coerce_version(item)
-
-        # Determine if we should be supporting prereleases in this specifier
-        # or not, if we do not support prereleases than we can short circuit
-        # logic if this version is a prereleases.
+ 
+        # Determine if we should be supporting prereleases in this specifier 
+        # or not, if we do not support prereleases than we can short circuit 
+        # logic if this version is a prereleases. 
         if normalized_item.is_prerelease and not prereleases:
-            return False
-
-        # Actually do the comparison to determine if this item is contained
-        # within this Specifier or not.
+            return False 
+ 
+        # Actually do the comparison to determine if this item is contained 
+        # within this Specifier or not. 
         operator_callable = self._get_operator(self.operator)  # type: CallableOperator
         return operator_callable(normalized_item, self.version)
-
-    def filter(self, iterable, prereleases=None):
+ 
+    def filter(self, iterable, prereleases=None): 
         # type: (Iterable[UnparsedVersion], Optional[bool]) -> Iterable[UnparsedVersion]
 
-        yielded = False
-        found_prereleases = []
-
-        kw = {"prereleases": prereleases if prereleases is not None else True}
-
-        # Attempt to iterate over all the values in the iterable and if any of
-        # them match, yield them.
-        for version in iterable:
-            parsed_version = self._coerce_version(version)
-
-            if self.contains(parsed_version, **kw):
-                # If our version is a prerelease, and we were not set to allow
-                # prereleases, then we'll store it for later incase nothing
-                # else matches this specifier.
+        yielded = False 
+        found_prereleases = [] 
+ 
+        kw = {"prereleases": prereleases if prereleases is not None else True} 
+ 
+        # Attempt to iterate over all the values in the iterable and if any of 
+        # them match, yield them. 
+        for version in iterable: 
+            parsed_version = self._coerce_version(version) 
+ 
+            if self.contains(parsed_version, **kw): 
+                # If our version is a prerelease, and we were not set to allow 
+                # prereleases, then we'll store it for later incase nothing 
+                # else matches this specifier. 
                 if parsed_version.is_prerelease and not (
                     prereleases or self.prereleases
                 ):
-                    found_prereleases.append(version)
-                # Either this is not a prerelease, or we should have been
+                    found_prereleases.append(version) 
+                # Either this is not a prerelease, or we should have been 
                 # accepting prereleases from the beginning.
-                else:
-                    yielded = True
-                    yield version
-
-        # Now that we've iterated over everything, determine if we've yielded
-        # any values, and if we have not and we have any prereleases stored up
-        # then we will go ahead and yield the prereleases.
-        if not yielded and found_prereleases:
-            for version in found_prereleases:
-                yield version
-
-
-class LegacySpecifier(_IndividualSpecifier):
-
+                else: 
+                    yielded = True 
+                    yield version 
+ 
+        # Now that we've iterated over everything, determine if we've yielded 
+        # any values, and if we have not and we have any prereleases stored up 
+        # then we will go ahead and yield the prereleases. 
+        if not yielded and found_prereleases: 
+            for version in found_prereleases: 
+                yield version 
+ 
+ 
+class LegacySpecifier(_IndividualSpecifier): 
+ 
     _regex_str = r"""
-        (?P<operator>(==|!=|<=|>=|<|>))
-        \s*
-        (?P<version>
-            [^,;\s)]* # Since this is a "legacy" specifier, and the version
-                      # string can be just about anything, we match everything
-                      # except for whitespace, a semi-colon for marker support,
-                      # a closing paren since versions can be enclosed in
-                      # them, and a comma since it's a version separator.
-        )
-        """
-
+        (?P<operator>(==|!=|<=|>=|<|>)) 
+        \s* 
+        (?P<version> 
+            [^,;\s)]* # Since this is a "legacy" specifier, and the version 
+                      # string can be just about anything, we match everything 
+                      # except for whitespace, a semi-colon for marker support, 
+                      # a closing paren since versions can be enclosed in 
+                      # them, and a comma since it's a version separator. 
+        ) 
+        """ 
+ 
     _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-    }
-
+ 
+    _operators = { 
+        "==": "equal", 
+        "!=": "not_equal", 
+        "<=": "less_than_equal", 
+        ">=": "greater_than_equal", 
+        "<": "less_than", 
+        ">": "greater_than", 
+    } 
+ 
     def __init__(self, spec="", prereleases=None):
         # type: (str, Optional[bool]) -> None
         super(LegacySpecifier, self).__init__(spec, prereleases)
@@ -286,530 +286,530 @@ class LegacySpecifier(_IndividualSpecifier):
             DeprecationWarning,
         )
 
-    def _coerce_version(self, version):
+    def _coerce_version(self, version): 
         # type: (Union[ParsedVersion, str]) -> LegacyVersion
-        if not isinstance(version, LegacyVersion):
-            version = LegacyVersion(str(version))
-        return version
-
-    def _compare_equal(self, prospective, spec):
+        if not isinstance(version, LegacyVersion): 
+            version = LegacyVersion(str(version)) 
+        return version 
+ 
+    def _compare_equal(self, prospective, spec): 
         # type: (LegacyVersion, str) -> bool
-        return prospective == self._coerce_version(spec)
-
-    def _compare_not_equal(self, prospective, spec):
+        return prospective == self._coerce_version(spec) 
+ 
+    def _compare_not_equal(self, prospective, spec): 
         # type: (LegacyVersion, str) -> bool
-        return prospective != self._coerce_version(spec)
-
-    def _compare_less_than_equal(self, prospective, spec):
+        return prospective != self._coerce_version(spec) 
+ 
+    def _compare_less_than_equal(self, prospective, spec): 
         # type: (LegacyVersion, str) -> bool
-        return prospective <= self._coerce_version(spec)
-
-    def _compare_greater_than_equal(self, prospective, spec):
+        return prospective <= self._coerce_version(spec) 
+ 
+    def _compare_greater_than_equal(self, prospective, spec): 
         # type: (LegacyVersion, str) -> bool
-        return prospective >= self._coerce_version(spec)
-
-    def _compare_less_than(self, prospective, spec):
+        return prospective >= self._coerce_version(spec) 
+ 
+    def _compare_less_than(self, prospective, spec): 
         # type: (LegacyVersion, str) -> bool
-        return prospective < self._coerce_version(spec)
-
-    def _compare_greater_than(self, prospective, spec):
+        return prospective < self._coerce_version(spec) 
+ 
+    def _compare_greater_than(self, prospective, spec): 
         # type: (LegacyVersion, str) -> bool
-        return prospective > self._coerce_version(spec)
-
-
+        return prospective > self._coerce_version(spec) 
+ 
+ 
 def _require_version_compare(
     fn,  # type: (Callable[[Specifier, ParsedVersion, str], bool])
 ):
     # type: (...) -> Callable[[Specifier, ParsedVersion, str], bool]
-    @functools.wraps(fn)
-    def wrapped(self, prospective, spec):
+    @functools.wraps(fn) 
+    def wrapped(self, prospective, spec): 
         # type: (Specifier, ParsedVersion, str) -> bool
-        if not isinstance(prospective, Version):
-            return False
-        return fn(self, prospective, spec)
-
-    return wrapped
-
-
-class Specifier(_IndividualSpecifier):
-
+        if not isinstance(prospective, Version): 
+            return False 
+        return fn(self, prospective, spec) 
+
+    return wrapped 
+ 
+ 
+class Specifier(_IndividualSpecifier): 
+ 
     _regex_str = r"""
-        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
-        (?P<version>
-            (?:
-                # The identity operators allow for an escape hatch that will
-                # do an exact string match of the version you wish to install.
-                # This will not be parsed by PEP 440 and we cannot determine
-                # any semantic meaning from it. This operator is discouraged
-                # but included entirely as an escape hatch.
-                (?<====)  # Only match for the identity operator
-                \s*
-                [^\s]*    # We just match everything, except for whitespace
-                          # since we are only testing for strict identity.
-            )
-            |
-            (?:
-                # The (non)equality operators allow for wild card and local
-                # versions to be specified so we have to define these two
-                # operators separately to enable that.
-                (?<===|!=)            # Only match for equals and not equals
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-
-                # You cannot use a wild card and a dev or local version
-                # together so group them with a | and make them optional.
-                (?:
-                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
-                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
-                    |
-                    \.\*  # Wild card syntax of .*
-                )?
-            )
-            |
-            (?:
-                # The compatible operator requires at least two digits in the
-                # release segment.
-                (?<=~=)               # Only match for the compatible operator
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-            |
-            (?:
-                # All other operators only allow a sub set of what the
-                # (non)equality operators do. Specifically they do not allow
-                # local versions to be specified nor do they allow the prefix
-                # matching wild cards.
-                (?<!==|!=|~=)         # We have special cases for these
-                                      # operators so we want to make sure they
-                                      # don't match here.
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-        )
-        """
-
+        (?P<operator>(~=|==|!=|<=|>=|<|>|===)) 
+        (?P<version> 
+            (?: 
+                # The identity operators allow for an escape hatch that will 
+                # do an exact string match of the version you wish to install. 
+                # This will not be parsed by PEP 440 and we cannot determine 
+                # any semantic meaning from it. This operator is discouraged 
+                # but included entirely as an escape hatch. 
+                (?<====)  # Only match for the identity operator 
+                \s* 
+                [^\s]*    # We just match everything, except for whitespace 
+                          # since we are only testing for strict identity. 
+            ) 
+            | 
+            (?: 
+                # The (non)equality operators allow for wild card and local 
+                # versions to be specified so we have to define these two 
+                # operators separately to enable that. 
+                (?<===|!=)            # Only match for equals and not equals 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)*   # release 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+ 
+                # You cannot use a wild card and a dev or local version 
+                # together so group them with a | and make them optional. 
+                (?: 
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release 
+                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local 
+                    | 
+                    \.\*  # Wild card syntax of .* 
+                )? 
+            ) 
+            | 
+            (?: 
+                # The compatible operator requires at least two digits in the 
+                # release segment. 
+                (?<=~=)               # Only match for the compatible operator 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *) 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release 
+            ) 
+            | 
+            (?: 
+                # All other operators only allow a sub set of what the 
+                # (non)equality operators do. Specifically they do not allow 
+                # local versions to be specified nor do they allow the prefix 
+                # matching wild cards. 
+                (?<!==|!=|~=)         # We have special cases for these 
+                                      # operators so we want to make sure they 
+                                      # don't match here. 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)*   # release 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release 
+            ) 
+        ) 
+        """ 
+ 
     _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "~=": "compatible",
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-        "===": "arbitrary",
-    }
-
-    @_require_version_compare
-    def _compare_compatible(self, prospective, spec):
+ 
+    _operators = { 
+        "~=": "compatible", 
+        "==": "equal", 
+        "!=": "not_equal", 
+        "<=": "less_than_equal", 
+        ">=": "greater_than_equal", 
+        "<": "less_than", 
+        ">": "greater_than", 
+        "===": "arbitrary", 
+    } 
+ 
+    @_require_version_compare 
+    def _compare_compatible(self, prospective, spec): 
         # type: (ParsedVersion, str) -> bool
 
-        # Compatible releases have an equivalent combination of >= and ==. That
-        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
-        # implement this in terms of the other specifiers instead of
-        # implementing it ourselves. The only thing we need to do is construct
-        # the other specifiers.
-
-        # We want everything but the last item in the version, but we want to
-        # ignore post and dev releases and we want to treat the pre-release as
-        # it's own separate segment.
-        prefix = ".".join(
-            list(
-                itertools.takewhile(
+        # Compatible releases have an equivalent combination of >= and ==. That 
+        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to 
+        # implement this in terms of the other specifiers instead of 
+        # implementing it ourselves. The only thing we need to do is construct 
+        # the other specifiers. 
+ 
+        # We want everything but the last item in the version, but we want to 
+        # ignore post and dev releases and we want to treat the pre-release as 
+        # it's own separate segment. 
+        prefix = ".".join( 
+            list( 
+                itertools.takewhile( 
                     lambda x: (not x.startswith("post") and not x.startswith("dev")),
-                    _version_split(spec),
-                )
-            )[:-1]
-        )
-
-        # Add the prefix notation to the end of our string
-        prefix += ".*"
-
+                    _version_split(spec), 
+                ) 
+            )[:-1] 
+        ) 
+ 
+        # Add the prefix notation to the end of our string 
+        prefix += ".*" 
+ 
         return self._get_operator(">=")(prospective, spec) and self._get_operator("==")(
             prospective, prefix
         )
-
-    @_require_version_compare
-    def _compare_equal(self, prospective, spec):
+ 
+    @_require_version_compare 
+    def _compare_equal(self, prospective, spec): 
         # type: (ParsedVersion, str) -> bool
 
-        # We need special logic to handle prefix matching
-        if spec.endswith(".*"):
-            # In the case of prefix matching we want to ignore local segment.
-            prospective = Version(prospective.public)
-            # Split the spec out by dots, and pretend that there is an implicit
-            # dot in between a release segment and a pre-release segment.
+        # We need special logic to handle prefix matching 
+        if spec.endswith(".*"): 
+            # In the case of prefix matching we want to ignore local segment. 
+            prospective = Version(prospective.public) 
+            # Split the spec out by dots, and pretend that there is an implicit 
+            # dot in between a release segment and a pre-release segment. 
             split_spec = _version_split(spec[:-2])  # Remove the trailing .*
-
-            # Split the prospective version out by dots, and pretend that there
-            # is an implicit dot in between a release segment and a pre-release
-            # segment.
+ 
+            # Split the prospective version out by dots, and pretend that there 
+            # is an implicit dot in between a release segment and a pre-release 
+            # segment. 
             split_prospective = _version_split(str(prospective))
-
-            # Shorten the prospective version to be the same length as the spec
-            # so that we can determine if the specifier is a prefix of the
-            # prospective version or not.
+ 
+            # Shorten the prospective version to be the same length as the spec 
+            # so that we can determine if the specifier is a prefix of the 
+            # prospective version or not. 
             shortened_prospective = split_prospective[: len(split_spec)]
-
-            # Pad out our two sides with zeros so that they both equal the same
-            # length.
+ 
+            # Pad out our two sides with zeros so that they both equal the same 
+            # length. 
             padded_spec, padded_prospective = _pad_version(
                 split_spec, shortened_prospective
             )
 
             return padded_prospective == padded_spec
-        else:
-            # Convert our spec string into a Version
+        else: 
+            # Convert our spec string into a Version 
             spec_version = Version(spec)
-
-            # If the specifier does not have a local segment, then we want to
-            # act as if the prospective version also does not have a local
-            # segment.
+ 
+            # If the specifier does not have a local segment, then we want to 
+            # act as if the prospective version also does not have a local 
+            # segment. 
             if not spec_version.local:
-                prospective = Version(prospective.public)
-
+                prospective = Version(prospective.public) 
+ 
             return prospective == spec_version
-
-    @_require_version_compare
-    def _compare_not_equal(self, prospective, spec):
+ 
+    @_require_version_compare 
+    def _compare_not_equal(self, prospective, spec): 
         # type: (ParsedVersion, str) -> bool
-        return not self._compare_equal(prospective, spec)
-
-    @_require_version_compare
-    def _compare_less_than_equal(self, prospective, spec):
+        return not self._compare_equal(prospective, spec) 
+ 
+    @_require_version_compare 
+    def _compare_less_than_equal(self, prospective, spec): 
         # type: (ParsedVersion, str) -> bool
-
+ 
         # NB: Local version identifiers are NOT permitted in the version
         # specifier, so local version labels can be universally removed from
         # the prospective version.
         return Version(prospective.public) <= Version(spec)
 
-    @_require_version_compare
-    def _compare_greater_than_equal(self, prospective, spec):
+    @_require_version_compare 
+    def _compare_greater_than_equal(self, prospective, spec): 
         # type: (ParsedVersion, str) -> bool
-
+ 
         # NB: Local version identifiers are NOT permitted in the version
         # specifier, so local version labels can be universally removed from
         # the prospective version.
         return Version(prospective.public) >= Version(spec)
 
-    @_require_version_compare
+    @_require_version_compare 
     def _compare_less_than(self, prospective, spec_str):
         # type: (ParsedVersion, str) -> bool
 
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
+        # Convert our spec to a Version instance, since we'll want to work with 
+        # it as a version. 
         spec = Version(spec_str)
-
-        # Check to see if the prospective version is less than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective < spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a pre-release version, that we do not accept pre-release
-        # versions for the version mentioned in the specifier (e.g. <3.1 should
-        # not match 3.1.dev0, but should match 3.0.dev0).
-        if not spec.is_prerelease and prospective.is_prerelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # less than the spec version *and* it's not a pre-release of the same
-        # version in the spec.
-        return True
-
-    @_require_version_compare
+ 
+        # Check to see if the prospective version is less than the spec 
+        # version. If it's not we can short circuit and just return False now 
+        # instead of doing extra unneeded work. 
+        if not prospective < spec: 
+            return False 
+ 
+        # This special case is here so that, unless the specifier itself 
+        # includes is a pre-release version, that we do not accept pre-release 
+        # versions for the version mentioned in the specifier (e.g. <3.1 should 
+        # not match 3.1.dev0, but should match 3.0.dev0). 
+        if not spec.is_prerelease and prospective.is_prerelease: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # If we've gotten to here, it means that prospective version is both 
+        # less than the spec version *and* it's not a pre-release of the same 
+        # version in the spec. 
+        return True 
+ 
+    @_require_version_compare 
     def _compare_greater_than(self, prospective, spec_str):
         # type: (ParsedVersion, str) -> bool
 
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
+        # Convert our spec to a Version instance, since we'll want to work with 
+        # it as a version. 
         spec = Version(spec_str)
-
-        # Check to see if the prospective version is greater than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective > spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a post-release version, that we do not accept
-        # post-release versions for the version mentioned in the specifier
-        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
-        if not spec.is_postrelease and prospective.is_postrelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # Ensure that we do not allow a local version of the version mentioned
+ 
+        # Check to see if the prospective version is greater than the spec 
+        # version. If it's not we can short circuit and just return False now 
+        # instead of doing extra unneeded work. 
+        if not prospective > spec: 
+            return False 
+ 
+        # This special case is here so that, unless the specifier itself 
+        # includes is a post-release version, that we do not accept 
+        # post-release versions for the version mentioned in the specifier 
+        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0). 
+        if not spec.is_postrelease and prospective.is_postrelease: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # Ensure that we do not allow a local version of the version mentioned 
         # in the specifier, which is technically greater than, to match.
-        if prospective.local is not None:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # greater than the spec version *and* it's not a pre-release of the
-        # same version in the spec.
-        return True
-
-    def _compare_arbitrary(self, prospective, spec):
+        if prospective.local is not None: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # If we've gotten to here, it means that prospective version is both 
+        # greater than the spec version *and* it's not a pre-release of the 
+        # same version in the spec. 
+        return True 
+ 
+    def _compare_arbitrary(self, prospective, spec): 
         # type: (Version, str) -> bool
-        return str(prospective).lower() == str(spec).lower()
-
-    @property
-    def prereleases(self):
+        return str(prospective).lower() == str(spec).lower() 
+ 
+    @property 
+    def prereleases(self): 
         # type: () -> bool
 
-        # If there is an explicit prereleases set for this, then we'll just
-        # blindly use that.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # Look at all of our specifiers and determine if they are inclusive
-        # operators, and if they are if they are including an explicit
-        # prerelease.
-        operator, version = self._spec
-        if operator in ["==", ">=", "<=", "~=", "==="]:
-            # The == specifier can include a trailing .*, if it does we
-            # want to remove before parsing.
-            if operator == "==" and version.endswith(".*"):
-                version = version[:-2]
-
-            # Parse the version, and if it is a pre-release than this
-            # specifier allows pre-releases.
-            if parse(version).is_prerelease:
-                return True
-
-        return False
-
-    @prereleases.setter
-    def prereleases(self, value):
+        # If there is an explicit prereleases set for this, then we'll just 
+        # blindly use that. 
+        if self._prereleases is not None: 
+            return self._prereleases 
+ 
+        # Look at all of our specifiers and determine if they are inclusive 
+        # operators, and if they are if they are including an explicit 
+        # prerelease. 
+        operator, version = self._spec 
+        if operator in ["==", ">=", "<=", "~=", "==="]: 
+            # The == specifier can include a trailing .*, if it does we 
+            # want to remove before parsing. 
+            if operator == "==" and version.endswith(".*"): 
+                version = version[:-2] 
+ 
+            # Parse the version, and if it is a pre-release than this 
+            # specifier allows pre-releases. 
+            if parse(version).is_prerelease: 
+                return True 
+ 
+        return False 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
         # type: (bool) -> None
-        self._prereleases = value
-
-
-_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
-
-
-def _version_split(version):
+        self._prereleases = value 
+ 
+ 
+_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$") 
+ 
+ 
+def _version_split(version): 
     # type: (str) -> List[str]
     result = []  # type: List[str]
-    for item in version.split("."):
-        match = _prefix_regex.search(item)
-        if match:
-            result.extend(match.groups())
-        else:
-            result.append(item)
-    return result
-
-
-def _pad_version(left, right):
+    for item in version.split("."): 
+        match = _prefix_regex.search(item) 
+        if match: 
+            result.extend(match.groups()) 
+        else: 
+            result.append(item) 
+    return result 
+ 
+ 
+def _pad_version(left, right): 
     # type: (List[str], List[str]) -> Tuple[List[str], List[str]]
-    left_split, right_split = [], []
-
-    # Get the release segment of our versions
-    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
-    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
-
-    # Get the rest of our versions
+    left_split, right_split = [], [] 
+ 
+    # Get the release segment of our versions 
+    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left))) 
+    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right))) 
+ 
+    # Get the rest of our versions 
     left_split.append(left[len(left_split[0]) :])
     right_split.append(right[len(right_split[0]) :])
-
-    # Insert our padding
+ 
+    # Insert our padding 
     left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0])))
     right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0])))
-
+ 
     return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split)))
-
-
-class SpecifierSet(BaseSpecifier):
+ 
+ 
+class SpecifierSet(BaseSpecifier): 
     def __init__(self, specifiers="", prereleases=None):
         # type: (str, Optional[bool]) -> None
-
+ 
         # Split on , to break each individual specifier into it's own item, and
-        # strip each item to remove leading/trailing whitespace.
+        # strip each item to remove leading/trailing whitespace. 
         split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
-
-        # Parsed each individual specifier, attempting first to make it a
-        # Specifier and falling back to a LegacySpecifier.
-        parsed = set()
+ 
+        # Parsed each individual specifier, attempting first to make it a 
+        # Specifier and falling back to a LegacySpecifier. 
+        parsed = set() 
         for specifier in split_specifiers:
-            try:
-                parsed.add(Specifier(specifier))
-            except InvalidSpecifier:
-                parsed.add(LegacySpecifier(specifier))
-
-        # Turn our parsed specifiers into a frozen set and save them for later.
-        self._specs = frozenset(parsed)
-
-        # Store our prereleases value so we can use it later to determine if
-        # we accept prereleases or not.
-        self._prereleases = prereleases
-
-    def __repr__(self):
+            try: 
+                parsed.add(Specifier(specifier)) 
+            except InvalidSpecifier: 
+                parsed.add(LegacySpecifier(specifier)) 
+ 
+        # Turn our parsed specifiers into a frozen set and save them for later. 
+        self._specs = frozenset(parsed) 
+ 
+        # Store our prereleases value so we can use it later to determine if 
+        # we accept prereleases or not. 
+        self._prereleases = prereleases 
+ 
+    def __repr__(self): 
         # type: () -> str
-        pre = (
-            ", prereleases={0!r}".format(self.prereleases)
-            if self._prereleases is not None
-            else ""
-        )
-
-        return "<SpecifierSet({0!r}{1})>".format(str(self), pre)
-
-    def __str__(self):
+        pre = ( 
+            ", prereleases={0!r}".format(self.prereleases) 
+            if self._prereleases is not None 
+            else "" 
+        ) 
+ 
+        return "<SpecifierSet({0!r}{1})>".format(str(self), pre) 
+ 
+    def __str__(self): 
         # type: () -> str
-        return ",".join(sorted(str(s) for s in self._specs))
-
-    def __hash__(self):
+        return ",".join(sorted(str(s) for s in self._specs)) 
+ 
+    def __hash__(self): 
         # type: () -> int
-        return hash(self._specs)
-
-    def __and__(self, other):
+        return hash(self._specs) 
+ 
+    def __and__(self, other): 
         # type: (Union[SpecifierSet, str]) -> SpecifierSet
-        if isinstance(other, string_types):
-            other = SpecifierSet(other)
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        specifier = SpecifierSet()
-        specifier._specs = frozenset(self._specs | other._specs)
-
-        if self._prereleases is None and other._prereleases is not None:
-            specifier._prereleases = other._prereleases
-        elif self._prereleases is not None and other._prereleases is None:
-            specifier._prereleases = self._prereleases
-        elif self._prereleases == other._prereleases:
-            specifier._prereleases = self._prereleases
-        else:
-            raise ValueError(
-                "Cannot combine SpecifierSets with True and False prerelease "
-                "overrides."
-            )
-
-        return specifier
-
-    def __eq__(self, other):
+        if isinstance(other, string_types): 
+            other = SpecifierSet(other) 
+        elif not isinstance(other, SpecifierSet): 
+            return NotImplemented 
+ 
+        specifier = SpecifierSet() 
+        specifier._specs = frozenset(self._specs | other._specs) 
+ 
+        if self._prereleases is None and other._prereleases is not None: 
+            specifier._prereleases = other._prereleases 
+        elif self._prereleases is not None and other._prereleases is None: 
+            specifier._prereleases = self._prereleases 
+        elif self._prereleases == other._prereleases: 
+            specifier._prereleases = self._prereleases 
+        else: 
+            raise ValueError( 
+                "Cannot combine SpecifierSets with True and False prerelease " 
+                "overrides." 
+            ) 
+ 
+        return specifier 
+ 
+    def __eq__(self, other): 
         # type: (object) -> bool
         if isinstance(other, (string_types, _IndividualSpecifier)):
-            other = SpecifierSet(str(other))
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        return self._specs == other._specs
-
-    def __ne__(self, other):
+            other = SpecifierSet(str(other)) 
+        elif not isinstance(other, SpecifierSet): 
+            return NotImplemented 
+ 
+        return self._specs == other._specs 
+ 
+    def __ne__(self, other): 
         # type: (object) -> bool
         if isinstance(other, (string_types, _IndividualSpecifier)):
-            other = SpecifierSet(str(other))
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        return self._specs != other._specs
-
-    def __len__(self):
+            other = SpecifierSet(str(other)) 
+        elif not isinstance(other, SpecifierSet): 
+            return NotImplemented 
+ 
+        return self._specs != other._specs 
+ 
+    def __len__(self): 
         # type: () -> int
-        return len(self._specs)
-
-    def __iter__(self):
+        return len(self._specs) 
+ 
+    def __iter__(self): 
         # type: () -> Iterator[_IndividualSpecifier]
-        return iter(self._specs)
-
-    @property
-    def prereleases(self):
+        return iter(self._specs) 
+ 
+    @property 
+    def prereleases(self): 
         # type: () -> Optional[bool]
 
-        # If we have been given an explicit prerelease modifier, then we'll
-        # pass that through here.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # If we don't have any specifiers, and we don't have a forced value,
-        # then we'll just return None since we don't know if this should have
-        # pre-releases or not.
-        if not self._specs:
-            return None
-
-        # Otherwise we'll see if any of the given specifiers accept
-        # prereleases, if any of them do we'll return True, otherwise False.
-        return any(s.prereleases for s in self._specs)
-
-    @prereleases.setter
-    def prereleases(self, value):
+        # If we have been given an explicit prerelease modifier, then we'll 
+        # pass that through here. 
+        if self._prereleases is not None: 
+            return self._prereleases 
+ 
+        # If we don't have any specifiers, and we don't have a forced value, 
+        # then we'll just return None since we don't know if this should have 
+        # pre-releases or not. 
+        if not self._specs: 
+            return None 
+ 
+        # Otherwise we'll see if any of the given specifiers accept 
+        # prereleases, if any of them do we'll return True, otherwise False. 
+        return any(s.prereleases for s in self._specs) 
+ 
+    @prereleases.setter 
+    def prereleases(self, value): 
         # type: (bool) -> None
-        self._prereleases = value
-
-    def __contains__(self, item):
+        self._prereleases = value 
+ 
+    def __contains__(self, item): 
         # type: (Union[ParsedVersion, str]) -> bool
-        return self.contains(item)
-
-    def contains(self, item, prereleases=None):
+        return self.contains(item) 
+ 
+    def contains(self, item, prereleases=None): 
         # type: (Union[ParsedVersion, str], Optional[bool]) -> bool
 
-        # Ensure that our item is a Version or LegacyVersion instance.
-        if not isinstance(item, (LegacyVersion, Version)):
-            item = parse(item)
-
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # We can determine if we're going to allow pre-releases by looking to
-        # see if any of the underlying items supports them. If none of them do
-        # and this item is a pre-release then we do not allow it and we can
-        # short circuit that here.
-        # Note: This means that 1.0.dev1 would not be contained in something
-        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
-        if not prereleases and item.is_prerelease:
-            return False
-
-        # We simply dispatch to the underlying specs here to make sure that the
-        # given version is contained within all of them.
-        # Note: This use of all() here means that an empty set of specifiers
-        #       will always return True, this is an explicit design decision.
+        # Ensure that our item is a Version or LegacyVersion instance. 
+        if not isinstance(item, (LegacyVersion, Version)): 
+            item = parse(item) 
+ 
+        # Determine if we're forcing a prerelease or not, if we're not forcing 
+        # one for this particular filter call, then we'll use whatever the 
+        # SpecifierSet thinks for whether or not we should support prereleases. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # We can determine if we're going to allow pre-releases by looking to 
+        # see if any of the underlying items supports them. If none of them do 
+        # and this item is a pre-release then we do not allow it and we can 
+        # short circuit that here. 
+        # Note: This means that 1.0.dev1 would not be contained in something 
+        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0 
+        if not prereleases and item.is_prerelease: 
+            return False 
+ 
+        # We simply dispatch to the underlying specs here to make sure that the 
+        # given version is contained within all of them. 
+        # Note: This use of all() here means that an empty set of specifiers 
+        #       will always return True, this is an explicit design decision. 
         return all(s.contains(item, prereleases=prereleases) for s in self._specs)
-
+ 
     def filter(
         self,
         iterable,  # type: Iterable[Union[ParsedVersion, str]]
@@ -817,48 +817,48 @@ class SpecifierSet(BaseSpecifier):
     ):
         # type: (...) -> Iterable[Union[ParsedVersion, str]]
 
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # If we have any specifiers, then we want to wrap our iterable in the
-        # filter method for each one, this will act as a logical AND amongst
-        # each specifier.
-        if self._specs:
-            for spec in self._specs:
-                iterable = spec.filter(iterable, prereleases=bool(prereleases))
-            return iterable
-        # If we do not have any specifiers, then we need to have a rough filter
-        # which will filter out any pre-releases, unless there are no final
-        # releases, and which will filter out LegacyVersion in general.
-        else:
+        # Determine if we're forcing a prerelease or not, if we're not forcing 
+        # one for this particular filter call, then we'll use whatever the 
+        # SpecifierSet thinks for whether or not we should support prereleases. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # If we have any specifiers, then we want to wrap our iterable in the 
+        # filter method for each one, this will act as a logical AND amongst 
+        # each specifier. 
+        if self._specs: 
+            for spec in self._specs: 
+                iterable = spec.filter(iterable, prereleases=bool(prereleases)) 
+            return iterable 
+        # If we do not have any specifiers, then we need to have a rough filter 
+        # which will filter out any pre-releases, unless there are no final 
+        # releases, and which will filter out LegacyVersion in general. 
+        else: 
             filtered = []  # type: List[Union[ParsedVersion, str]]
             found_prereleases = []  # type: List[Union[ParsedVersion, str]]
-
-            for item in iterable:
-                # Ensure that we some kind of Version class for this item.
-                if not isinstance(item, (LegacyVersion, Version)):
-                    parsed_version = parse(item)
-                else:
-                    parsed_version = item
-
-                # Filter out any item which is parsed as a LegacyVersion
-                if isinstance(parsed_version, LegacyVersion):
-                    continue
-
-                # Store any item which is a pre-release for later unless we've
-                # already found a final version or we are accepting prereleases
-                if parsed_version.is_prerelease and not prereleases:
-                    if not filtered:
-                        found_prereleases.append(item)
-                else:
-                    filtered.append(item)
-
-            # If we've found no items except for pre-releases, then we'll go
-            # ahead and use the pre-releases
-            if not filtered and found_prereleases and prereleases is None:
-                return found_prereleases
-
-            return filtered
+ 
+            for item in iterable: 
+                # Ensure that we some kind of Version class for this item. 
+                if not isinstance(item, (LegacyVersion, Version)): 
+                    parsed_version = parse(item) 
+                else: 
+                    parsed_version = item 
+ 
+                # Filter out any item which is parsed as a LegacyVersion 
+                if isinstance(parsed_version, LegacyVersion): 
+                    continue 
+ 
+                # Store any item which is a pre-release for later unless we've 
+                # already found a final version or we are accepting prereleases 
+                if parsed_version.is_prerelease and not prereleases: 
+                    if not filtered: 
+                        found_prereleases.append(item) 
+                else: 
+                    filtered.append(item) 
+ 
+            # If we've found no items except for pre-releases, then we'll go 
+            # ahead and use the pre-releases 
+            if not filtered and found_prereleases and prereleases is None: 
+                return found_prereleases 
+ 
+            return filtered 
diff --git a/contrib/python/packaging/py2/packaging/utils.py b/contrib/python/packaging/py2/packaging/utils.py
index 6e8c2a3e5b..7fcba8a8f8 100644
--- a/contrib/python/packaging/py2/packaging/utils.py
+++ b/contrib/python/packaging/py2/packaging/utils.py
@@ -1,14 +1,14 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import re
-
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import re 
+ 
 from ._typing import TYPE_CHECKING, cast
 from .tags import Tag, parse_tag
 from .version import InvalidVersion, Version
-
+ 
 if TYPE_CHECKING:  # pragma: no cover
     from typing import FrozenSet, NewType, Tuple, Union
 
@@ -31,14 +31,14 @@ class InvalidSdistFilename(ValueError):
     """
 
 
-_canonicalize_regex = re.compile(r"[-_.]+")
+_canonicalize_regex = re.compile(r"[-_.]+") 
 # PEP 427: The build number must start with a digit.
 _build_tag_regex = re.compile(r"(\d+)(.*)")
-
-
-def canonicalize_name(name):
+ 
+ 
+def canonicalize_name(name): 
     # type: (str) -> NormalizedName
-    # This is taken from PEP 503.
+    # This is taken from PEP 503. 
     value = _canonicalize_regex.sub("-", name).lower()
     return cast(NormalizedName, value)
 
diff --git a/contrib/python/packaging/py2/packaging/version.py b/contrib/python/packaging/py2/packaging/version.py
index 517d91f248..e687e63cb6 100644
--- a/contrib/python/packaging/py2/packaging/version.py
+++ b/contrib/python/packaging/py2/packaging/version.py
@@ -1,21 +1,21 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-from __future__ import absolute_import, division, print_function
-
-import collections
-import itertools
-import re
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+from __future__ import absolute_import, division, print_function 
+ 
+import collections 
+import itertools 
+import re 
 import warnings
-
+ 
 from ._structures import Infinity, NegativeInfinity
 from ._typing import TYPE_CHECKING
-
+ 
 if TYPE_CHECKING:  # pragma: no cover
     from typing import Callable, Iterator, List, Optional, SupportsInt, Tuple, Union
-
+ 
     from ._structures import InfinityType, NegativeInfinityType
-
+ 
     InfiniteTypes = Union[InfinityType, NegativeInfinityType]
     PrePostDevType = Union[InfiniteTypes, Tuple[str, int]]
     SubLocalType = Union[InfiniteTypes, int, str]
@@ -37,118 +37,118 @@ if TYPE_CHECKING:  # pragma: no cover
     VersionComparisonMethod = Callable[
         [Union[CmpKey, LegacyCmpKey], Union[CmpKey, LegacyCmpKey]], bool
     ]
-
+ 
 __all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"]
 
 
-_Version = collections.namedtuple(
+_Version = collections.namedtuple( 
     "_Version", ["epoch", "release", "dev", "pre", "post", "local"]
-)
-
-
-def parse(version):
+) 
+ 
+ 
+def parse(version): 
     # type: (str) -> Union[LegacyVersion, Version]
-    """
-    Parse the given version string and return either a :class:`Version` object
-    or a :class:`LegacyVersion` object depending on if the given version is
-    a valid PEP 440 version or a legacy version.
-    """
-    try:
-        return Version(version)
-    except InvalidVersion:
-        return LegacyVersion(version)
-
-
-class InvalidVersion(ValueError):
-    """
-    An invalid version was found, users should refer to PEP 440.
-    """
-
-
-class _BaseVersion(object):
+    """ 
+    Parse the given version string and return either a :class:`Version` object 
+    or a :class:`LegacyVersion` object depending on if the given version is 
+    a valid PEP 440 version or a legacy version. 
+    """ 
+    try: 
+        return Version(version) 
+    except InvalidVersion: 
+        return LegacyVersion(version) 
+ 
+ 
+class InvalidVersion(ValueError): 
+    """ 
+    An invalid version was found, users should refer to PEP 440. 
+    """ 
+ 
+ 
+class _BaseVersion(object): 
     _key = None  # type: Union[CmpKey, LegacyCmpKey]
-
-    def __hash__(self):
+ 
+    def __hash__(self): 
         # type: () -> int
-        return hash(self._key)
-
+        return hash(self._key) 
+ 
     # Please keep the duplicated `isinstance` check
     # in the six comparisons hereunder
     # unless you find a way to avoid adding overhead function calls.
-    def __lt__(self, other):
+    def __lt__(self, other): 
         # type: (_BaseVersion) -> bool
         if not isinstance(other, _BaseVersion):
             return NotImplemented
-
+ 
         return self._key < other._key
 
-    def __le__(self, other):
+    def __le__(self, other): 
         # type: (_BaseVersion) -> bool
         if not isinstance(other, _BaseVersion):
             return NotImplemented
-
+ 
         return self._key <= other._key
 
-    def __eq__(self, other):
+    def __eq__(self, other): 
         # type: (object) -> bool
         if not isinstance(other, _BaseVersion):
             return NotImplemented
-
+ 
         return self._key == other._key
 
-    def __ge__(self, other):
+    def __ge__(self, other): 
         # type: (_BaseVersion) -> bool
         if not isinstance(other, _BaseVersion):
             return NotImplemented
-
+ 
         return self._key >= other._key
 
-    def __gt__(self, other):
+    def __gt__(self, other): 
         # type: (_BaseVersion) -> bool
         if not isinstance(other, _BaseVersion):
             return NotImplemented
-
+ 
         return self._key > other._key
 
-    def __ne__(self, other):
+    def __ne__(self, other): 
         # type: (object) -> bool
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-
+        if not isinstance(other, _BaseVersion): 
+            return NotImplemented 
+ 
         return self._key != other._key
-
-
-class LegacyVersion(_BaseVersion):
-    def __init__(self, version):
+ 
+ 
+class LegacyVersion(_BaseVersion): 
+    def __init__(self, version): 
         # type: (str) -> None
-        self._version = str(version)
-        self._key = _legacy_cmpkey(self._version)
-
+        self._version = str(version) 
+        self._key = _legacy_cmpkey(self._version) 
+ 
         warnings.warn(
             "Creating a LegacyVersion has been deprecated and will be "
             "removed in the next major release",
             DeprecationWarning,
         )
 
-    def __str__(self):
+    def __str__(self): 
         # type: () -> str
-        return self._version
-
-    def __repr__(self):
+        return self._version 
+ 
+    def __repr__(self): 
         # type: () -> str
-        return "<LegacyVersion({0})>".format(repr(str(self)))
-
-    @property
-    def public(self):
+        return "<LegacyVersion({0})>".format(repr(str(self))) 
+ 
+    @property 
+    def public(self): 
         # type: () -> str
-        return self._version
-
-    @property
-    def base_version(self):
+        return self._version 
+ 
+    @property 
+    def base_version(self): 
         # type: () -> str
-        return self._version
-
-    @property
+        return self._version 
+ 
+    @property 
     def epoch(self):
         # type: () -> int
         return -1
@@ -174,185 +174,185 @@ class LegacyVersion(_BaseVersion):
         return None
 
     @property
-    def local(self):
+    def local(self): 
         # type: () -> None
-        return None
-
-    @property
-    def is_prerelease(self):
+        return None 
+ 
+    @property 
+    def is_prerelease(self): 
         # type: () -> bool
-        return False
-
-    @property
-    def is_postrelease(self):
+        return False 
+ 
+    @property 
+    def is_postrelease(self): 
         # type: () -> bool
-        return False
-
+        return False 
+ 
     @property
     def is_devrelease(self):
         # type: () -> bool
         return False
-
+ 
 
 _legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE)
-
-_legacy_version_replacement_map = {
+ 
+_legacy_version_replacement_map = { 
     "pre": "c",
     "preview": "c",
     "-": "final-",
     "rc": "c",
     "dev": "@",
-}
-
-
-def _parse_version_parts(s):
+} 
+ 
+ 
+def _parse_version_parts(s): 
     # type: (str) -> Iterator[str]
-    for part in _legacy_version_component_re.split(s):
-        part = _legacy_version_replacement_map.get(part, part)
-
-        if not part or part == ".":
-            continue
-
-        if part[:1] in "0123456789":
-            # pad for numeric comparison
-            yield part.zfill(8)
-        else:
-            yield "*" + part
-
-    # ensure that alpha/beta/candidate are before final
-    yield "*final"
-
-
-def _legacy_cmpkey(version):
+    for part in _legacy_version_component_re.split(s): 
+        part = _legacy_version_replacement_map.get(part, part) 
+ 
+        if not part or part == ".": 
+            continue 
+ 
+        if part[:1] in "0123456789": 
+            # pad for numeric comparison 
+            yield part.zfill(8) 
+        else: 
+            yield "*" + part 
+ 
+    # ensure that alpha/beta/candidate are before final 
+    yield "*final" 
+ 
+ 
+def _legacy_cmpkey(version): 
     # type: (str) -> LegacyCmpKey
 
-    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
-    # greater than or equal to 0. This will effectively put the LegacyVersion,
-    # which uses the defacto standard originally implemented by setuptools,
-    # as before all PEP 440 versions.
-    epoch = -1
-
-    # This scheme is taken from pkg_resources.parse_version setuptools prior to
-    # it's adoption of the packaging library.
+    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch 
+    # greater than or equal to 0. This will effectively put the LegacyVersion, 
+    # which uses the defacto standard originally implemented by setuptools, 
+    # as before all PEP 440 versions. 
+    epoch = -1 
+ 
+    # This scheme is taken from pkg_resources.parse_version setuptools prior to 
+    # it's adoption of the packaging library. 
     parts = []  # type: List[str]
-    for part in _parse_version_parts(version.lower()):
-        if part.startswith("*"):
-            # remove "-" before a prerelease tag
-            if part < "*final":
-                while parts and parts[-1] == "*final-":
-                    parts.pop()
-
-            # remove trailing zeros from each series of numeric parts
-            while parts and parts[-1] == "00000000":
-                parts.pop()
-
-        parts.append(part)
-
+    for part in _parse_version_parts(version.lower()): 
+        if part.startswith("*"): 
+            # remove "-" before a prerelease tag 
+            if part < "*final": 
+                while parts and parts[-1] == "*final-": 
+                    parts.pop() 
+ 
+            # remove trailing zeros from each series of numeric parts 
+            while parts and parts[-1] == "00000000": 
+                parts.pop() 
+ 
+        parts.append(part) 
+ 
     return epoch, tuple(parts)
-
-
-# Deliberately not anchored to the start and end of the string, to make it
-# easier for 3rd party code to reuse
-VERSION_PATTERN = r"""
-    v?
-    (?:
-        (?:(?P<epoch>[0-9]+)!)?                           # epoch
-        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
-        (?P<pre>                                          # pre-release
-            [-_\.]?
-            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
-            [-_\.]?
-            (?P<pre_n>[0-9]+)?
-        )?
-        (?P<post>                                         # post release
-            (?:-(?P<post_n1>[0-9]+))
-            |
-            (?:
-                [-_\.]?
-                (?P<post_l>post|rev|r)
-                [-_\.]?
-                (?P<post_n2>[0-9]+)?
-            )
-        )?
-        (?P<dev>                                          # dev release
-            [-_\.]?
-            (?P<dev_l>dev)
-            [-_\.]?
-            (?P<dev_n>[0-9]+)?
-        )?
-    )
-    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
-"""
-
-
-class Version(_BaseVersion):
-
+ 
+
+# Deliberately not anchored to the start and end of the string, to make it 
+# easier for 3rd party code to reuse 
+VERSION_PATTERN = r""" 
+    v? 
+    (?: 
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch 
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment 
+        (?P<pre>                                          # pre-release 
+            [-_\.]? 
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview)) 
+            [-_\.]? 
+            (?P<pre_n>[0-9]+)? 
+        )? 
+        (?P<post>                                         # post release 
+            (?:-(?P<post_n1>[0-9]+)) 
+            | 
+            (?: 
+                [-_\.]? 
+                (?P<post_l>post|rev|r) 
+                [-_\.]? 
+                (?P<post_n2>[0-9]+)? 
+            ) 
+        )? 
+        (?P<dev>                                          # dev release 
+            [-_\.]? 
+            (?P<dev_l>dev) 
+            [-_\.]? 
+            (?P<dev_n>[0-9]+)? 
+        )? 
+    ) 
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version 
+""" 
+ 
+ 
+class Version(_BaseVersion): 
+ 
     _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    def __init__(self, version):
+ 
+    def __init__(self, version): 
         # type: (str) -> None
 
-        # Validate the version and parse it into pieces
-        match = self._regex.search(version)
-        if not match:
-            raise InvalidVersion("Invalid version: '{0}'".format(version))
-
-        # Store the parsed out pieces of the version
-        self._version = _Version(
-            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
-            release=tuple(int(i) for i in match.group("release").split(".")),
+        # Validate the version and parse it into pieces 
+        match = self._regex.search(version) 
+        if not match: 
+            raise InvalidVersion("Invalid version: '{0}'".format(version)) 
+ 
+        # Store the parsed out pieces of the version 
+        self._version = _Version( 
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0, 
+            release=tuple(int(i) for i in match.group("release").split(".")), 
             pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
-            post=_parse_letter_version(
+            post=_parse_letter_version( 
                 match.group("post_l"), match.group("post_n1") or match.group("post_n2")
-            ),
+            ), 
             dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
-            local=_parse_local_version(match.group("local")),
-        )
-
-        # Generate a key which will be used for sorting
-        self._key = _cmpkey(
-            self._version.epoch,
-            self._version.release,
-            self._version.pre,
-            self._version.post,
-            self._version.dev,
-            self._version.local,
-        )
-
-    def __repr__(self):
+            local=_parse_local_version(match.group("local")), 
+        ) 
+ 
+        # Generate a key which will be used for sorting 
+        self._key = _cmpkey( 
+            self._version.epoch, 
+            self._version.release, 
+            self._version.pre, 
+            self._version.post, 
+            self._version.dev, 
+            self._version.local, 
+        ) 
+ 
+    def __repr__(self): 
         # type: () -> str
-        return "<Version({0})>".format(repr(str(self)))
-
-    def __str__(self):
+        return "<Version({0})>".format(repr(str(self))) 
+ 
+    def __str__(self): 
         # type: () -> str
-        parts = []
-
-        # Epoch
+        parts = [] 
+ 
+        # Epoch 
         if self.epoch != 0:
             parts.append("{0}!".format(self.epoch))
-
-        # Release segment
+ 
+        # Release segment 
         parts.append(".".join(str(x) for x in self.release))
-
-        # Pre-release
+ 
+        # Pre-release 
         if self.pre is not None:
             parts.append("".join(str(x) for x in self.pre))
-
-        # Post-release
+ 
+        # Post-release 
         if self.post is not None:
             parts.append(".post{0}".format(self.post))
-
-        # Development release
+ 
+        # Development release 
         if self.dev is not None:
             parts.append(".dev{0}".format(self.dev))
-
-        # Local version segment
+ 
+        # Local version segment 
         if self.local is not None:
             parts.append("+{0}".format(self.local))
-
-        return "".join(parts)
-
-    @property
+ 
+        return "".join(parts) 
+ 
+    @property 
     def epoch(self):
         # type: () -> int
         _epoch = self._version.epoch  # type: int
@@ -389,39 +389,39 @@ class Version(_BaseVersion):
             return None
 
     @property
-    def public(self):
+    def public(self): 
         # type: () -> str
-        return str(self).split("+", 1)[0]
-
-    @property
-    def base_version(self):
+        return str(self).split("+", 1)[0] 
+ 
+    @property 
+    def base_version(self): 
         # type: () -> str
-        parts = []
-
-        # Epoch
+        parts = [] 
+ 
+        # Epoch 
         if self.epoch != 0:
             parts.append("{0}!".format(self.epoch))
-
-        # Release segment
+ 
+        # Release segment 
         parts.append(".".join(str(x) for x in self.release))
-
-        return "".join(parts)
-
-    @property
-    def is_prerelease(self):
+ 
+        return "".join(parts) 
+ 
+    @property 
+    def is_prerelease(self): 
         # type: () -> bool
         return self.dev is not None or self.pre is not None
-
-    @property
-    def is_postrelease(self):
+ 
+    @property 
+    def is_postrelease(self): 
         # type: () -> bool
         return self.post is not None
-
+ 
     @property
     def is_devrelease(self):
         # type: () -> bool
         return self.dev is not None
-
+ 
     @property
     def major(self):
         # type: () -> int
@@ -444,54 +444,54 @@ def _parse_letter_version(
 ):
     # type: (...) -> Optional[Tuple[str, int]]
 
-    if letter:
-        # We consider there to be an implicit 0 in a pre-release if there is
-        # not a numeral associated with it.
-        if number is None:
-            number = 0
-
-        # We normalize any letters to their lower case form
-        letter = letter.lower()
-
-        # We consider some words to be alternate spellings of other words and
-        # in those cases we want to normalize the spellings to our preferred
-        # spelling.
-        if letter == "alpha":
-            letter = "a"
-        elif letter == "beta":
-            letter = "b"
-        elif letter in ["c", "pre", "preview"]:
-            letter = "rc"
-        elif letter in ["rev", "r"]:
-            letter = "post"
-
-        return letter, int(number)
-    if not letter and number:
-        # We assume if we are given a number, but we are not given a letter
-        # then this is using the implicit post release syntax (e.g. 1.0-1)
-        letter = "post"
-
-        return letter, int(number)
-
+    if letter: 
+        # We consider there to be an implicit 0 in a pre-release if there is 
+        # not a numeral associated with it. 
+        if number is None: 
+            number = 0 
+ 
+        # We normalize any letters to their lower case form 
+        letter = letter.lower() 
+ 
+        # We consider some words to be alternate spellings of other words and 
+        # in those cases we want to normalize the spellings to our preferred 
+        # spelling. 
+        if letter == "alpha": 
+            letter = "a" 
+        elif letter == "beta": 
+            letter = "b" 
+        elif letter in ["c", "pre", "preview"]: 
+            letter = "rc" 
+        elif letter in ["rev", "r"]: 
+            letter = "post" 
+ 
+        return letter, int(number) 
+    if not letter and number: 
+        # We assume if we are given a number, but we are not given a letter 
+        # then this is using the implicit post release syntax (e.g. 1.0-1) 
+        letter = "post" 
+ 
+        return letter, int(number) 
+ 
     return None
-
+ 
 
 _local_version_separators = re.compile(r"[\._-]")
-
-
-def _parse_local_version(local):
+ 
+ 
+def _parse_local_version(local): 
     # type: (str) -> Optional[LocalType]
-    """
-    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
-    """
-    if local is not None:
-        return tuple(
-            part.lower() if not part.isdigit() else int(part)
+    """ 
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve"). 
+    """ 
+    if local is not None: 
+        return tuple( 
+            part.lower() if not part.isdigit() else int(part) 
             for part in _local_version_separators.split(local)
-        )
+        ) 
     return None
-
-
+ 
+ 
 def _cmpkey(
     epoch,  # type: int
     release,  # type: Tuple[int, ...]
@@ -502,55 +502,55 @@ def _cmpkey(
 ):
     # type: (...) -> CmpKey
 
-    # When we compare a release version, we want to compare it with all of the
-    # trailing zeros removed. So we'll use a reverse the list, drop all the now
-    # leading zeros until we come to something non zero, then take the rest
-    # re-reverse it back into the correct order and make it a tuple and use
-    # that for our sorting key.
+    # When we compare a release version, we want to compare it with all of the 
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now 
+    # leading zeros until we come to something non zero, then take the rest 
+    # re-reverse it back into the correct order and make it a tuple and use 
+    # that for our sorting key. 
     _release = tuple(
         reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
-    )
-
-    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
-    # We'll do this by abusing the pre segment, but we _only_ want to do this
-    # if there is not a pre or a post segment. If we have one of those then
-    # the normal sorting rules will handle this case correctly.
-    if pre is None and post is None and dev is not None:
+    ) 
+ 
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0. 
+    # We'll do this by abusing the pre segment, but we _only_ want to do this 
+    # if there is not a pre or a post segment. If we have one of those then 
+    # the normal sorting rules will handle this case correctly. 
+    if pre is None and post is None and dev is not None: 
         _pre = NegativeInfinity  # type: PrePostDevType
-    # Versions without a pre-release (except as noted above) should sort after
-    # those with one.
-    elif pre is None:
+    # Versions without a pre-release (except as noted above) should sort after 
+    # those with one. 
+    elif pre is None: 
         _pre = Infinity
     else:
         _pre = pre
-
-    # Versions without a post segment should sort before those with one.
-    if post is None:
+ 
+    # Versions without a post segment should sort before those with one. 
+    if post is None: 
         _post = NegativeInfinity  # type: PrePostDevType
-
+ 
     else:
         _post = post
 
-    # Versions without a development segment should sort after those with one.
-    if dev is None:
+    # Versions without a development segment should sort after those with one. 
+    if dev is None: 
         _dev = Infinity  # type: PrePostDevType
-
+ 
     else:
         _dev = dev
 
-    if local is None:
-        # Versions without a local segment should sort before those with one.
+    if local is None: 
+        # Versions without a local segment should sort before those with one. 
         _local = NegativeInfinity  # type: LocalType
-    else:
-        # Versions with a local segment need that segment parsed to implement
-        # the sorting rules in PEP440.
-        # - Alpha numeric segments sort before numeric segments
-        # - Alpha numeric segments sort lexicographically
-        # - Numeric segments sort numerically
-        # - Shorter versions sort before longer versions when the prefixes
-        #   match exactly
+    else: 
+        # Versions with a local segment need that segment parsed to implement 
+        # the sorting rules in PEP440. 
+        # - Alpha numeric segments sort before numeric segments 
+        # - Alpha numeric segments sort lexicographically 
+        # - Numeric segments sort numerically 
+        # - Shorter versions sort before longer versions when the prefixes 
+        #   match exactly 
         _local = tuple(
             (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
-        )
-
+        ) 
+ 
     return epoch, _release, _pre, _post, _dev, _local
diff --git a/contrib/python/packaging/py2/ya.make b/contrib/python/packaging/py2/ya.make
index 916ebde32c..2680f0f210 100644
--- a/contrib/python/packaging/py2/ya.make
+++ b/contrib/python/packaging/py2/ya.make
@@ -1,34 +1,34 @@
 # Generated by devtools/yamaker (pypi).
 
 PY2_LIBRARY()
-
+ 
 OWNER(orivej g:python-contrib)
 
 VERSION(20.9)
-
+ 
 LICENSE(BSD-3-Clause)
 
-PEERDIR(
-    contrib/python/pyparsing
-)
-
+PEERDIR( 
+    contrib/python/pyparsing 
+) 
+ 
 NO_LINT()
 
-PY_SRCS(
-    TOP_LEVEL
+PY_SRCS( 
+    TOP_LEVEL 
     packaging/__about__.py
-    packaging/__init__.py
-    packaging/_compat.py
-    packaging/_structures.py
+    packaging/__init__.py 
+    packaging/_compat.py 
+    packaging/_structures.py 
     packaging/_typing.py
-    packaging/markers.py
-    packaging/requirements.py
-    packaging/specifiers.py
+    packaging/markers.py 
+    packaging/requirements.py 
+    packaging/specifiers.py 
     packaging/tags.py
-    packaging/utils.py
-    packaging/version.py
-)
-
+    packaging/utils.py 
+    packaging/version.py 
+) 
+ 
 RESOURCE_FILES(
     PREFIX contrib/python/packaging/py2/
     .dist-info/METADATA
@@ -36,4 +36,4 @@ RESOURCE_FILES(
     packaging/py.typed
 )
 
-END()
+END() 
diff --git a/contrib/python/packaging/py3/packaging/__init__.py b/contrib/python/packaging/py3/packaging/__init__.py
index 3c50c5dcfe..9e7be5ef16 100644
--- a/contrib/python/packaging/py3/packaging/__init__.py
+++ b/contrib/python/packaging/py3/packaging/__init__.py
@@ -1,6 +1,6 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
 
 from .__about__ import (
     __author__,
diff --git a/contrib/python/packaging/py3/packaging/_structures.py b/contrib/python/packaging/py3/packaging/_structures.py
index 90a6465f96..a54460baf7 100644
--- a/contrib/python/packaging/py3/packaging/_structures.py
+++ b/contrib/python/packaging/py3/packaging/_structures.py
@@ -1,61 +1,61 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+ 
+ 
 class InfinityType:
     def __repr__(self) -> str:
-        return "Infinity"
-
+        return "Infinity" 
+ 
     def __hash__(self) -> int:
-        return hash(repr(self))
-
+        return hash(repr(self)) 
+ 
     def __lt__(self, other: object) -> bool:
-        return False
-
+        return False 
+ 
     def __le__(self, other: object) -> bool:
-        return False
-
+        return False 
+ 
     def __eq__(self, other: object) -> bool:
-        return isinstance(other, self.__class__)
-
+        return isinstance(other, self.__class__) 
+ 
     def __gt__(self, other: object) -> bool:
-        return True
-
+        return True 
+ 
     def __ge__(self, other: object) -> bool:
-        return True
-
+        return True 
+ 
     def __neg__(self: object) -> "NegativeInfinityType":
-        return NegativeInfinity
-
+        return NegativeInfinity 
+ 
 
 Infinity = InfinityType()
-
-
+ 
+ 
 class NegativeInfinityType:
     def __repr__(self) -> str:
-        return "-Infinity"
-
+        return "-Infinity" 
+ 
     def __hash__(self) -> int:
-        return hash(repr(self))
-
+        return hash(repr(self)) 
+ 
     def __lt__(self, other: object) -> bool:
-        return True
-
+        return True 
+ 
     def __le__(self, other: object) -> bool:
-        return True
-
+        return True 
+ 
     def __eq__(self, other: object) -> bool:
-        return isinstance(other, self.__class__)
-
+        return isinstance(other, self.__class__) 
+ 
     def __gt__(self, other: object) -> bool:
-        return False
-
+        return False 
+ 
     def __ge__(self, other: object) -> bool:
-        return False
-
+        return False 
+ 
     def __neg__(self: object) -> InfinityType:
-        return Infinity
-
+        return Infinity 
+ 
 
 NegativeInfinity = NegativeInfinityType()
diff --git a/contrib/python/packaging/py3/packaging/markers.py b/contrib/python/packaging/py3/packaging/markers.py
index cb640e8f9b..7932ce6be5 100644
--- a/contrib/python/packaging/py3/packaging/markers.py
+++ b/contrib/python/packaging/py3/packaging/markers.py
@@ -1,13 +1,13 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-import operator
-import os
-import platform
-import sys
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+ 
+import operator 
+import os 
+import platform 
+import sys 
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-
+ 
 from pyparsing import (  # noqa: N817
     Forward,
     Group,
@@ -19,69 +19,69 @@ from pyparsing import (  # noqa: N817
     stringEnd,
     stringStart,
 )
-
+ 
 from .specifiers import InvalidSpecifier, Specifier
-
-__all__ = [
+ 
+__all__ = [ 
     "InvalidMarker",
     "UndefinedComparison",
     "UndefinedEnvironmentName",
     "Marker",
     "default_environment",
-]
-
+] 
+ 
 Operator = Callable[[str, str], bool]
-
-
-class InvalidMarker(ValueError):
-    """
-    An invalid marker was found, users should refer to PEP 508.
-    """
-
-
-class UndefinedComparison(ValueError):
-    """
-    An invalid operation was attempted on a value that doesn't support it.
-    """
-
-
-class UndefinedEnvironmentName(ValueError):
-    """
-    A name was attempted to be used that does not exist inside of the
-    environment.
-    """
-
-
+ 
+
+class InvalidMarker(ValueError): 
+    """ 
+    An invalid marker was found, users should refer to PEP 508. 
+    """ 
+ 
+ 
+class UndefinedComparison(ValueError): 
+    """ 
+    An invalid operation was attempted on a value that doesn't support it. 
+    """ 
+ 
+ 
+class UndefinedEnvironmentName(ValueError): 
+    """ 
+    A name was attempted to be used that does not exist inside of the 
+    environment. 
+    """ 
+ 
+ 
 class Node:
     def __init__(self, value: Any) -> None:
-        self.value = value
-
+        self.value = value 
+ 
     def __str__(self) -> str:
-        return str(self.value)
-
+        return str(self.value) 
+ 
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}('{self}')>"
-
+ 
     def serialize(self) -> str:
-        raise NotImplementedError
-
-
-class Variable(Node):
+        raise NotImplementedError 
+ 
+ 
+class Variable(Node): 
     def serialize(self) -> str:
-        return str(self)
-
-
-class Value(Node):
+        return str(self) 
+ 
+ 
+class Value(Node): 
     def serialize(self) -> str:
         return f'"{self}"'
-
-
-class Op(Node):
+ 
+ 
+class Op(Node): 
     def serialize(self) -> str:
-        return str(self)
-
-
-VARIABLE = (
+        return str(self) 
+ 
+ 
+VARIABLE = ( 
     L("implementation_version")
     | L("platform_python_implementation")
     | L("implementation_name")
@@ -100,205 +100,205 @@ VARIABLE = (
     | L("platform.python_implementation")  # PEP-345
     | L("python_implementation")  # undocumented setuptools legacy
     | L("extra")  # PEP-508
-)
-ALIASES = {
+) 
+ALIASES = { 
     "os.name": "os_name",
     "sys.platform": "sys_platform",
     "platform.version": "platform_version",
     "platform.machine": "platform_machine",
     "platform.python_implementation": "platform_python_implementation",
     "python_implementation": "platform_python_implementation",
-}
-VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))
-
-VERSION_CMP = (
+} 
+VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0]))) 
+ 
+VERSION_CMP = ( 
     L("===") | L("==") | L(">=") | L("<=") | L("!=") | L("~=") | L(">") | L("<")
-)
-
-MARKER_OP = VERSION_CMP | L("not in") | L("in")
-MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))
-
-MARKER_VALUE = QuotedString("'") | QuotedString('"')
-MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
-
-BOOLOP = L("and") | L("or")
-
-MARKER_VAR = VARIABLE | MARKER_VALUE
-
-MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
-MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
-
-LPAREN = L("(").suppress()
-RPAREN = L(")").suppress()
-
-MARKER_EXPR = Forward()
-MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
-MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
-
-MARKER = stringStart + MARKER_EXPR + stringEnd
-
-
+) 
+ 
+MARKER_OP = VERSION_CMP | L("not in") | L("in") 
+MARKER_OP.setParseAction(lambda s, l, t: Op(t[0])) 
+ 
+MARKER_VALUE = QuotedString("'") | QuotedString('"') 
+MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0])) 
+ 
+BOOLOP = L("and") | L("or") 
+ 
+MARKER_VAR = VARIABLE | MARKER_VALUE 
+ 
+MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR) 
+MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0])) 
+ 
+LPAREN = L("(").suppress() 
+RPAREN = L(")").suppress() 
+ 
+MARKER_EXPR = Forward() 
+MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN) 
+MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR) 
+ 
+MARKER = stringStart + MARKER_EXPR + stringEnd 
+ 
+ 
 def _coerce_parse_result(results: Union[ParseResults, List[Any]]) -> List[Any]:
-    if isinstance(results, ParseResults):
-        return [_coerce_parse_result(i) for i in results]
-    else:
-        return results
-
-
+    if isinstance(results, ParseResults): 
+        return [_coerce_parse_result(i) for i in results] 
+    else: 
+        return results 
+ 
+ 
 def _format_marker(
     marker: Union[List[str], Tuple[Node, ...], str], first: Optional[bool] = True
 ) -> str:
 
     assert isinstance(marker, (list, tuple, str))
-
-    # Sometimes we have a structure like [[...]] which is a single item list
-    # where the single item is itself it's own list. In that case we want skip
-    # the rest of this function so that we don't get extraneous () on the
-    # outside.
+ 
+    # Sometimes we have a structure like [[...]] which is a single item list 
+    # where the single item is itself it's own list. In that case we want skip 
+    # the rest of this function so that we don't get extraneous () on the 
+    # outside. 
     if (
         isinstance(marker, list)
         and len(marker) == 1
         and isinstance(marker[0], (list, tuple))
     ):
-        return _format_marker(marker[0])
-
-    if isinstance(marker, list):
-        inner = (_format_marker(m, first=False) for m in marker)
-        if first:
-            return " ".join(inner)
-        else:
-            return "(" + " ".join(inner) + ")"
-    elif isinstance(marker, tuple):
-        return " ".join([m.serialize() for m in marker])
-    else:
-        return marker
-
-
+        return _format_marker(marker[0]) 
+ 
+    if isinstance(marker, list): 
+        inner = (_format_marker(m, first=False) for m in marker) 
+        if first: 
+            return " ".join(inner) 
+        else: 
+            return "(" + " ".join(inner) + ")" 
+    elif isinstance(marker, tuple): 
+        return " ".join([m.serialize() for m in marker]) 
+    else: 
+        return marker 
+ 
+ 
 _operators: Dict[str, Operator] = {
-    "in": lambda lhs, rhs: lhs in rhs,
-    "not in": lambda lhs, rhs: lhs not in rhs,
-    "<": operator.lt,
-    "<=": operator.le,
-    "==": operator.eq,
-    "!=": operator.ne,
-    ">=": operator.ge,
-    ">": operator.gt,
+    "in": lambda lhs, rhs: lhs in rhs, 
+    "not in": lambda lhs, rhs: lhs not in rhs, 
+    "<": operator.lt, 
+    "<=": operator.le, 
+    "==": operator.eq, 
+    "!=": operator.ne, 
+    ">=": operator.ge, 
+    ">": operator.gt, 
 }
-
-
+ 
+ 
 def _eval_op(lhs: str, op: Op, rhs: str) -> bool:
-    try:
-        spec = Specifier("".join([op.serialize(), rhs]))
-    except InvalidSpecifier:
-        pass
-    else:
-        return spec.contains(lhs)
-
+    try: 
+        spec = Specifier("".join([op.serialize(), rhs])) 
+    except InvalidSpecifier: 
+        pass 
+    else: 
+        return spec.contains(lhs) 
+ 
     oper: Optional[Operator] = _operators.get(op.serialize())
-    if oper is None:
+    if oper is None: 
         raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.")
-
-    return oper(lhs, rhs)
-
-
+ 
+    return oper(lhs, rhs) 
+ 
+ 
 class Undefined:
     pass
-
-
+ 
+ 
 _undefined = Undefined()
 
 
 def _get_env(environment: Dict[str, str], name: str) -> str:
     value: Union[str, Undefined] = environment.get(name, _undefined)
-
+ 
     if isinstance(value, Undefined):
-        raise UndefinedEnvironmentName(
+        raise UndefinedEnvironmentName( 
             f"{name!r} does not exist in evaluation environment."
-        )
-
-    return value
-
-
+        ) 
+ 
+    return value 
+ 
+ 
 def _evaluate_markers(markers: List[Any], environment: Dict[str, str]) -> bool:
     groups: List[List[bool]] = [[]]
-
-    for marker in markers:
+ 
+    for marker in markers: 
         assert isinstance(marker, (list, tuple, str))
-
-        if isinstance(marker, list):
-            groups[-1].append(_evaluate_markers(marker, environment))
-        elif isinstance(marker, tuple):
-            lhs, op, rhs = marker
-
-            if isinstance(lhs, Variable):
-                lhs_value = _get_env(environment, lhs.value)
-                rhs_value = rhs.value
-            else:
-                lhs_value = lhs.value
-                rhs_value = _get_env(environment, rhs.value)
-
-            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
-        else:
-            assert marker in ["and", "or"]
-            if marker == "or":
-                groups.append([])
-
-    return any(all(item) for item in groups)
-
-
+ 
+        if isinstance(marker, list): 
+            groups[-1].append(_evaluate_markers(marker, environment)) 
+        elif isinstance(marker, tuple): 
+            lhs, op, rhs = marker 
+ 
+            if isinstance(lhs, Variable): 
+                lhs_value = _get_env(environment, lhs.value) 
+                rhs_value = rhs.value 
+            else: 
+                lhs_value = lhs.value 
+                rhs_value = _get_env(environment, rhs.value) 
+ 
+            groups[-1].append(_eval_op(lhs_value, op, rhs_value)) 
+        else: 
+            assert marker in ["and", "or"] 
+            if marker == "or": 
+                groups.append([]) 
+ 
+    return any(all(item) for item in groups) 
+ 
+ 
 def format_full_version(info: "sys._version_info") -> str:
     version = "{0.major}.{0.minor}.{0.micro}".format(info)
-    kind = info.releaselevel
+    kind = info.releaselevel 
     if kind != "final":
-        version += kind[0] + str(info.serial)
-    return version
-
-
+        version += kind[0] + str(info.serial) 
+    return version 
+ 
+ 
 def default_environment() -> Dict[str, str]:
     iver = format_full_version(sys.implementation.version)
     implementation_name = sys.implementation.name
-    return {
-        "implementation_name": implementation_name,
-        "implementation_version": iver,
-        "os_name": os.name,
-        "platform_machine": platform.machine(),
-        "platform_release": platform.release(),
-        "platform_system": platform.system(),
-        "platform_version": platform.version(),
-        "python_full_version": platform.python_version(),
-        "platform_python_implementation": platform.python_implementation(),
+    return { 
+        "implementation_name": implementation_name, 
+        "implementation_version": iver, 
+        "os_name": os.name, 
+        "platform_machine": platform.machine(), 
+        "platform_release": platform.release(), 
+        "platform_system": platform.system(), 
+        "platform_version": platform.version(), 
+        "python_full_version": platform.python_version(), 
+        "platform_python_implementation": platform.python_implementation(), 
         "python_version": ".".join(platform.python_version_tuple()[:2]),
-        "sys_platform": sys.platform,
-    }
-
-
+        "sys_platform": sys.platform, 
+    } 
+ 
+ 
 class Marker:
     def __init__(self, marker: str) -> None:
-        try:
-            self._markers = _coerce_parse_result(MARKER.parseString(marker))
-        except ParseException as e:
+        try: 
+            self._markers = _coerce_parse_result(MARKER.parseString(marker)) 
+        except ParseException as e: 
             raise InvalidMarker(
                 f"Invalid marker: {marker!r}, parse error at "
                 f"{marker[e.loc : e.loc + 8]!r}"
             )
-
+ 
     def __str__(self) -> str:
-        return _format_marker(self._markers)
-
+        return _format_marker(self._markers) 
+ 
     def __repr__(self) -> str:
         return f"<Marker('{self}')>"
-
+ 
     def evaluate(self, environment: Optional[Dict[str, str]] = None) -> bool:
-        """Evaluate a marker.
-
-        Return the boolean from evaluating the given marker against the
-        environment. environment is an optional argument to override all or
-        part of the determined environment.
-
-        The environment is determined from the current Python process.
-        """
-        current_environment = default_environment()
-        if environment is not None:
-            current_environment.update(environment)
-
-        return _evaluate_markers(self._markers, current_environment)
+        """Evaluate a marker. 
+ 
+        Return the boolean from evaluating the given marker against the 
+        environment. environment is an optional argument to override all or 
+        part of the determined environment. 
+ 
+        The environment is determined from the current Python process. 
+        """ 
+        current_environment = default_environment() 
+        if environment is not None: 
+            current_environment.update(environment) 
+ 
+        return _evaluate_markers(self._markers, current_environment) 
diff --git a/contrib/python/packaging/py3/packaging/requirements.py b/contrib/python/packaging/py3/packaging/requirements.py
index 53f9a3aa42..a83a8e7946 100644
--- a/contrib/python/packaging/py3/packaging/requirements.py
+++ b/contrib/python/packaging/py3/packaging/requirements.py
@@ -1,12 +1,12 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+ 
 import re
-import string
+import string 
 import urllib.parse
 from typing import List, Optional as TOptional, Set
-
+ 
 from pyparsing import (  # noqa
     Combine,
     Literal as L,
@@ -19,94 +19,94 @@ from pyparsing import (  # noqa
     stringEnd,
     stringStart,
 )
-
-from .markers import MARKER_EXPR, Marker
-from .specifiers import LegacySpecifier, Specifier, SpecifierSet
-
-
-class InvalidRequirement(ValueError):
-    """
-    An invalid requirement was found, users should refer to PEP 508.
-    """
-
-
-ALPHANUM = Word(string.ascii_letters + string.digits)
-
-LBRACKET = L("[").suppress()
-RBRACKET = L("]").suppress()
-LPAREN = L("(").suppress()
-RPAREN = L(")").suppress()
-COMMA = L(",").suppress()
-SEMICOLON = L(";").suppress()
-AT = L("@").suppress()
-
-PUNCTUATION = Word("-_.")
-IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
-IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
-
-NAME = IDENTIFIER("name")
-EXTRA = IDENTIFIER
-
+ 
+from .markers import MARKER_EXPR, Marker 
+from .specifiers import LegacySpecifier, Specifier, SpecifierSet 
+ 
+
+class InvalidRequirement(ValueError): 
+    """ 
+    An invalid requirement was found, users should refer to PEP 508. 
+    """ 
+ 
+ 
+ALPHANUM = Word(string.ascii_letters + string.digits) 
+ 
+LBRACKET = L("[").suppress() 
+RBRACKET = L("]").suppress() 
+LPAREN = L("(").suppress() 
+RPAREN = L(")").suppress() 
+COMMA = L(",").suppress() 
+SEMICOLON = L(";").suppress() 
+AT = L("@").suppress() 
+ 
+PUNCTUATION = Word("-_.") 
+IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM) 
+IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END)) 
+ 
+NAME = IDENTIFIER("name") 
+EXTRA = IDENTIFIER 
+ 
 URI = Regex(r"[^ ]+")("url")
 URL = AT + URI
-
-EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
-EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
-
-VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE)
-VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE)
-
-VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
+ 
+EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA) 
+EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras") 
+ 
+VERSION_PEP440 = Regex(Specifier._regex_str, re.VERBOSE | re.IGNORECASE) 
+VERSION_LEGACY = Regex(LegacySpecifier._regex_str, re.VERBOSE | re.IGNORECASE) 
+ 
+VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY 
 VERSION_MANY = Combine(
     VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE), joinString=",", adjacent=False
 )("_raw_spec")
 _VERSION_SPEC = Optional((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY)
 _VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or "")
-
-VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
-VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
-
-MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
-MARKER_EXPR.setParseAction(
+ 
+VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier") 
+VERSION_SPEC.setParseAction(lambda s, l, t: t[1]) 
+ 
+MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker") 
+MARKER_EXPR.setParseAction( 
     lambda s, l, t: Marker(s[t._original_start : t._original_end])
-)
+) 
 MARKER_SEPARATOR = SEMICOLON
 MARKER = MARKER_SEPARATOR + MARKER_EXPR
-
-VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
-URL_AND_MARKER = URL + Optional(MARKER)
-
+ 
+VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER) 
+URL_AND_MARKER = URL + Optional(MARKER) 
+ 
 NAMED_REQUIREMENT = NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
-
-REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
+ 
+REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd 
 # pyparsing isn't thread safe during initialization, so we do it eagerly, see
 # issue #104
 REQUIREMENT.parseString("x[]")
-
-
+ 
+ 
 class Requirement:
-    """Parse a requirement.
-
-    Parse a given requirement string into its parts, such as name, specifier,
-    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
-    string.
-    """
-
-    # TODO: Can we test whether something is contained within a requirement?
-    #       If so how do we do that? Do we need to test against the _name_ of
-    #       the thing as well as the version? What about the markers?
-    # TODO: Can we normalize the name and extra name?
-
+    """Parse a requirement. 
+ 
+    Parse a given requirement string into its parts, such as name, specifier, 
+    URL, and extras. Raises InvalidRequirement on a badly-formed requirement 
+    string. 
+    """ 
+ 
+    # TODO: Can we test whether something is contained within a requirement? 
+    #       If so how do we do that? Do we need to test against the _name_ of 
+    #       the thing as well as the version? What about the markers? 
+    # TODO: Can we normalize the name and extra name? 
+ 
     def __init__(self, requirement_string: str) -> None:
-        try:
-            req = REQUIREMENT.parseString(requirement_string)
-        except ParseException as e:
+        try: 
+            req = REQUIREMENT.parseString(requirement_string) 
+        except ParseException as e: 
             raise InvalidRequirement(
                 f'Parse error at "{ requirement_string[e.loc : e.loc + 8]!r}": {e.msg}'
             )
-
+ 
         self.name: str = req.name
-        if req.url:
+        if req.url: 
             parsed_url = urllib.parse.urlparse(req.url)
             if parsed_url.scheme == "file":
                 if urllib.parse.urlunparse(parsed_url) != req.url:
@@ -116,31 +116,31 @@ class Requirement:
             ):
                 raise InvalidRequirement(f"Invalid URL: {req.url}")
             self.url: TOptional[str] = req.url
-        else:
-            self.url = None
+        else: 
+            self.url = None 
         self.extras: Set[str] = set(req.extras.asList() if req.extras else [])
         self.specifier: SpecifierSet = SpecifierSet(req.specifier)
         self.marker: TOptional[Marker] = req.marker if req.marker else None
-
+ 
     def __str__(self) -> str:
         parts: List[str] = [self.name]
-
-        if self.extras:
+ 
+        if self.extras: 
             formatted_extras = ",".join(sorted(self.extras))
             parts.append(f"[{formatted_extras}]")
-
-        if self.specifier:
-            parts.append(str(self.specifier))
-
-        if self.url:
+ 
+        if self.specifier: 
+            parts.append(str(self.specifier)) 
+ 
+        if self.url: 
             parts.append(f"@ {self.url}")
             if self.marker:
                 parts.append(" ")
-
-        if self.marker:
+ 
+        if self.marker: 
             parts.append(f"; {self.marker}")
-
-        return "".join(parts)
-
+ 
+        return "".join(parts) 
+ 
     def __repr__(self) -> str:
         return f"<Requirement('{self}')>"
diff --git a/contrib/python/packaging/py3/packaging/specifiers.py b/contrib/python/packaging/py3/packaging/specifiers.py
index 0e218a6f9f..f4415f6cce 100644
--- a/contrib/python/packaging/py3/packaging/specifiers.py
+++ b/contrib/python/packaging/py3/packaging/specifiers.py
@@ -1,11 +1,11 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-import abc
-import functools
-import itertools
-import re
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+ 
+import abc 
+import functools 
+import itertools 
+import re 
 import warnings
 from typing import (
     Callable,
@@ -20,235 +20,235 @@ from typing import (
     TypeVar,
     Union,
 )
-
+ 
 from .utils import canonicalize_version
 from .version import LegacyVersion, Version, parse
-
+ 
 ParsedVersion = Union[Version, LegacyVersion]
 UnparsedVersion = Union[Version, LegacyVersion, str]
 VersionTypeVar = TypeVar("VersionTypeVar", bound=UnparsedVersion)
 CallableOperator = Callable[[ParsedVersion, str], bool]
-
-
-class InvalidSpecifier(ValueError):
-    """
-    An invalid specifier was found, users should refer to PEP 440.
-    """
-
-
+ 
+
+class InvalidSpecifier(ValueError): 
+    """ 
+    An invalid specifier was found, users should refer to PEP 440. 
+    """ 
+ 
+ 
 class BaseSpecifier(metaclass=abc.ABCMeta):
-    @abc.abstractmethod
+    @abc.abstractmethod 
     def __str__(self) -> str:
-        """
-        Returns the str representation of this Specifier like object. This
-        should be representative of the Specifier itself.
-        """
-
-    @abc.abstractmethod
+        """ 
+        Returns the str representation of this Specifier like object. This 
+        should be representative of the Specifier itself. 
+        """ 
+ 
+    @abc.abstractmethod 
     def __hash__(self) -> int:
-        """
-        Returns a hash value for this Specifier like object.
-        """
-
-    @abc.abstractmethod
+        """ 
+        Returns a hash value for this Specifier like object. 
+        """ 
+ 
+    @abc.abstractmethod 
     def __eq__(self, other: object) -> bool:
-        """
-        Returns a boolean representing whether or not the two Specifier like
-        objects are equal.
-        """
-
-    @abc.abstractproperty
+        """ 
+        Returns a boolean representing whether or not the two Specifier like 
+        objects are equal. 
+        """ 
+ 
+    @abc.abstractproperty 
     def prereleases(self) -> Optional[bool]:
-        """
-        Returns whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @prereleases.setter
+        """ 
+        Returns whether or not pre-releases as a whole are allowed by this 
+        specifier. 
+        """ 
+ 
+    @prereleases.setter 
     def prereleases(self, value: bool) -> None:
-        """
-        Sets whether or not pre-releases as a whole are allowed by this
-        specifier.
-        """
-
-    @abc.abstractmethod
+        """ 
+        Sets whether or not pre-releases as a whole are allowed by this 
+        specifier. 
+        """ 
+ 
+    @abc.abstractmethod 
     def contains(self, item: str, prereleases: Optional[bool] = None) -> bool:
-        """
-        Determines if the given item is contained within this specifier.
-        """
-
-    @abc.abstractmethod
+        """ 
+        Determines if the given item is contained within this specifier. 
+        """ 
+ 
+    @abc.abstractmethod 
     def filter(
         self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
     ) -> Iterable[VersionTypeVar]:
-        """
-        Takes an iterable of items and filters them so that only items which
-        are contained within this specifier are allowed in it.
-        """
-
-
-class _IndividualSpecifier(BaseSpecifier):
-
+        """ 
+        Takes an iterable of items and filters them so that only items which 
+        are contained within this specifier are allowed in it. 
+        """ 
+ 
+ 
+class _IndividualSpecifier(BaseSpecifier): 
+ 
     _operators: Dict[str, str] = {}
     _regex: Pattern[str]
-
+ 
     def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None:
-        match = self._regex.search(spec)
-        if not match:
+        match = self._regex.search(spec) 
+        if not match: 
             raise InvalidSpecifier(f"Invalid specifier: '{spec}'")
-
+ 
         self._spec: Tuple[str, str] = (
-            match.group("operator").strip(),
-            match.group("version").strip(),
+            match.group("operator").strip(), 
+            match.group("version").strip(), 
         )
-
-        # Store whether or not this Specifier should accept prereleases
-        self._prereleases = prereleases
-
+ 
+        # Store whether or not this Specifier should accept prereleases 
+        self._prereleases = prereleases 
+ 
     def __repr__(self) -> str:
-        pre = (
+        pre = ( 
             f", prereleases={self.prereleases!r}"
-            if self._prereleases is not None
-            else ""
-        )
-
+            if self._prereleases is not None 
+            else "" 
+        ) 
+ 
         return f"<{self.__class__.__name__}({str(self)!r}{pre})>"
-
+ 
     def __str__(self) -> str:
         return "{}{}".format(*self._spec)
-
+ 
     @property
     def _canonical_spec(self) -> Tuple[str, str]:
         return self._spec[0], canonicalize_version(self._spec[1])
 
     def __hash__(self) -> int:
         return hash(self._canonical_spec)
-
+ 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, str):
-            try:
+            try: 
                 other = self.__class__(str(other))
-            except InvalidSpecifier:
-                return NotImplemented
-        elif not isinstance(other, self.__class__):
-            return NotImplemented
-
+            except InvalidSpecifier: 
+                return NotImplemented 
+        elif not isinstance(other, self.__class__): 
+            return NotImplemented 
+ 
         return self._canonical_spec == other._canonical_spec
-
+ 
     def _get_operator(self, op: str) -> CallableOperator:
         operator_callable: CallableOperator = getattr(
             self, f"_compare_{self._operators[op]}"
         )
         return operator_callable
-
+ 
     def _coerce_version(self, version: UnparsedVersion) -> ParsedVersion:
-        if not isinstance(version, (LegacyVersion, Version)):
-            version = parse(version)
-        return version
-
-    @property
+        if not isinstance(version, (LegacyVersion, Version)): 
+            version = parse(version) 
+        return version 
+ 
+    @property 
     def operator(self) -> str:
-        return self._spec[0]
-
-    @property
+        return self._spec[0] 
+ 
+    @property 
     def version(self) -> str:
-        return self._spec[1]
-
-    @property
+        return self._spec[1] 
+ 
+    @property 
     def prereleases(self) -> Optional[bool]:
-        return self._prereleases
-
-    @prereleases.setter
+        return self._prereleases 
+ 
+    @prereleases.setter 
     def prereleases(self, value: bool) -> None:
-        self._prereleases = value
-
+        self._prereleases = value 
+ 
     def __contains__(self, item: str) -> bool:
-        return self.contains(item)
-
+        return self.contains(item) 
+ 
     def contains(
         self, item: UnparsedVersion, prereleases: Optional[bool] = None
     ) -> bool:
 
-        # Determine if prereleases are to be allowed or not.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # Normalize item to a Version or LegacyVersion, this allows us to have
-        # a shortcut for ``"2.0" in Specifier(">=2")
+        # Determine if prereleases are to be allowed or not. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # Normalize item to a Version or LegacyVersion, this allows us to have 
+        # a shortcut for ``"2.0" in Specifier(">=2") 
         normalized_item = self._coerce_version(item)
-
-        # Determine if we should be supporting prereleases in this specifier
-        # or not, if we do not support prereleases than we can short circuit
-        # logic if this version is a prereleases.
+ 
+        # Determine if we should be supporting prereleases in this specifier 
+        # or not, if we do not support prereleases than we can short circuit 
+        # logic if this version is a prereleases. 
         if normalized_item.is_prerelease and not prereleases:
-            return False
-
-        # Actually do the comparison to determine if this item is contained
-        # within this Specifier or not.
+            return False 
+ 
+        # Actually do the comparison to determine if this item is contained 
+        # within this Specifier or not. 
         operator_callable: CallableOperator = self._get_operator(self.operator)
         return operator_callable(normalized_item, self.version)
-
+ 
     def filter(
         self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
     ) -> Iterable[VersionTypeVar]:
 
-        yielded = False
-        found_prereleases = []
-
-        kw = {"prereleases": prereleases if prereleases is not None else True}
-
-        # Attempt to iterate over all the values in the iterable and if any of
-        # them match, yield them.
-        for version in iterable:
-            parsed_version = self._coerce_version(version)
-
-            if self.contains(parsed_version, **kw):
-                # If our version is a prerelease, and we were not set to allow
+        yielded = False 
+        found_prereleases = [] 
+ 
+        kw = {"prereleases": prereleases if prereleases is not None else True} 
+ 
+        # Attempt to iterate over all the values in the iterable and if any of 
+        # them match, yield them. 
+        for version in iterable: 
+            parsed_version = self._coerce_version(version) 
+ 
+            if self.contains(parsed_version, **kw): 
+                # If our version is a prerelease, and we were not set to allow 
                 # prereleases, then we'll store it for later in case nothing
-                # else matches this specifier.
+                # else matches this specifier. 
                 if parsed_version.is_prerelease and not (
                     prereleases or self.prereleases
                 ):
-                    found_prereleases.append(version)
-                # Either this is not a prerelease, or we should have been
+                    found_prereleases.append(version) 
+                # Either this is not a prerelease, or we should have been 
                 # accepting prereleases from the beginning.
-                else:
-                    yielded = True
-                    yield version
-
-        # Now that we've iterated over everything, determine if we've yielded
-        # any values, and if we have not and we have any prereleases stored up
-        # then we will go ahead and yield the prereleases.
-        if not yielded and found_prereleases:
-            for version in found_prereleases:
-                yield version
-
-
-class LegacySpecifier(_IndividualSpecifier):
-
+                else: 
+                    yielded = True 
+                    yield version 
+ 
+        # Now that we've iterated over everything, determine if we've yielded 
+        # any values, and if we have not and we have any prereleases stored up 
+        # then we will go ahead and yield the prereleases. 
+        if not yielded and found_prereleases: 
+            for version in found_prereleases: 
+                yield version 
+ 
+ 
+class LegacySpecifier(_IndividualSpecifier): 
+ 
     _regex_str = r"""
-        (?P<operator>(==|!=|<=|>=|<|>))
-        \s*
-        (?P<version>
-            [^,;\s)]* # Since this is a "legacy" specifier, and the version
-                      # string can be just about anything, we match everything
-                      # except for whitespace, a semi-colon for marker support,
-                      # a closing paren since versions can be enclosed in
-                      # them, and a comma since it's a version separator.
-        )
-        """
-
+        (?P<operator>(==|!=|<=|>=|<|>)) 
+        \s* 
+        (?P<version> 
+            [^,;\s)]* # Since this is a "legacy" specifier, and the version 
+                      # string can be just about anything, we match everything 
+                      # except for whitespace, a semi-colon for marker support, 
+                      # a closing paren since versions can be enclosed in 
+                      # them, and a comma since it's a version separator. 
+        ) 
+        """ 
+ 
     _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-    }
-
+ 
+    _operators = { 
+        "==": "equal", 
+        "!=": "not_equal", 
+        "<=": "less_than_equal", 
+        ">=": "greater_than_equal", 
+        "<": "less_than", 
+        ">": "greater_than", 
+    } 
+ 
     def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None:
         super().__init__(spec, prereleases)
 
@@ -259,340 +259,340 @@ class LegacySpecifier(_IndividualSpecifier):
         )
 
     def _coerce_version(self, version: UnparsedVersion) -> LegacyVersion:
-        if not isinstance(version, LegacyVersion):
-            version = LegacyVersion(str(version))
-        return version
-
+        if not isinstance(version, LegacyVersion): 
+            version = LegacyVersion(str(version)) 
+        return version 
+ 
     def _compare_equal(self, prospective: LegacyVersion, spec: str) -> bool:
-        return prospective == self._coerce_version(spec)
-
+        return prospective == self._coerce_version(spec) 
+ 
     def _compare_not_equal(self, prospective: LegacyVersion, spec: str) -> bool:
-        return prospective != self._coerce_version(spec)
-
+        return prospective != self._coerce_version(spec) 
+ 
     def _compare_less_than_equal(self, prospective: LegacyVersion, spec: str) -> bool:
-        return prospective <= self._coerce_version(spec)
-
+        return prospective <= self._coerce_version(spec) 
+ 
     def _compare_greater_than_equal(
         self, prospective: LegacyVersion, spec: str
     ) -> bool:
-        return prospective >= self._coerce_version(spec)
-
+        return prospective >= self._coerce_version(spec) 
+ 
     def _compare_less_than(self, prospective: LegacyVersion, spec: str) -> bool:
-        return prospective < self._coerce_version(spec)
-
+        return prospective < self._coerce_version(spec) 
+ 
     def _compare_greater_than(self, prospective: LegacyVersion, spec: str) -> bool:
-        return prospective > self._coerce_version(spec)
-
-
+        return prospective > self._coerce_version(spec) 
+ 
+ 
 def _require_version_compare(
     fn: Callable[["Specifier", ParsedVersion, str], bool]
 ) -> Callable[["Specifier", ParsedVersion, str], bool]:
-    @functools.wraps(fn)
+    @functools.wraps(fn) 
     def wrapped(self: "Specifier", prospective: ParsedVersion, spec: str) -> bool:
-        if not isinstance(prospective, Version):
-            return False
-        return fn(self, prospective, spec)
-
-    return wrapped
-
-
-class Specifier(_IndividualSpecifier):
-
+        if not isinstance(prospective, Version): 
+            return False 
+        return fn(self, prospective, spec) 
+
+    return wrapped 
+ 
+ 
+class Specifier(_IndividualSpecifier): 
+ 
     _regex_str = r"""
-        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
-        (?P<version>
-            (?:
-                # The identity operators allow for an escape hatch that will
-                # do an exact string match of the version you wish to install.
-                # This will not be parsed by PEP 440 and we cannot determine
-                # any semantic meaning from it. This operator is discouraged
-                # but included entirely as an escape hatch.
-                (?<====)  # Only match for the identity operator
-                \s*
-                [^\s]*    # We just match everything, except for whitespace
-                          # since we are only testing for strict identity.
-            )
-            |
-            (?:
-                # The (non)equality operators allow for wild card and local
-                # versions to be specified so we have to define these two
-                # operators separately to enable that.
-                (?<===|!=)            # Only match for equals and not equals
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-
-                # You cannot use a wild card and a dev or local version
-                # together so group them with a | and make them optional.
-                (?:
-                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
-                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
-                    |
-                    \.\*  # Wild card syntax of .*
-                )?
-            )
-            |
-            (?:
-                # The compatible operator requires at least two digits in the
-                # release segment.
-                (?<=~=)               # Only match for the compatible operator
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-            |
-            (?:
-                # All other operators only allow a sub set of what the
-                # (non)equality operators do. Specifically they do not allow
-                # local versions to be specified nor do they allow the prefix
-                # matching wild cards.
-                (?<!==|!=|~=)         # We have special cases for these
-                                      # operators so we want to make sure they
-                                      # don't match here.
-
-                \s*
-                v?
-                (?:[0-9]+!)?          # epoch
-                [0-9]+(?:\.[0-9]+)*   # release
-                (?:                   # pre release
-                    [-_\.]?
-                    (a|b|c|rc|alpha|beta|pre|preview)
-                    [-_\.]?
-                    [0-9]*
-                )?
-                (?:                                   # post release
-                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
-                )?
-                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
-            )
-        )
-        """
-
+        (?P<operator>(~=|==|!=|<=|>=|<|>|===)) 
+        (?P<version> 
+            (?: 
+                # The identity operators allow for an escape hatch that will 
+                # do an exact string match of the version you wish to install. 
+                # This will not be parsed by PEP 440 and we cannot determine 
+                # any semantic meaning from it. This operator is discouraged 
+                # but included entirely as an escape hatch. 
+                (?<====)  # Only match for the identity operator 
+                \s* 
+                [^\s]*    # We just match everything, except for whitespace 
+                          # since we are only testing for strict identity. 
+            ) 
+            | 
+            (?: 
+                # The (non)equality operators allow for wild card and local 
+                # versions to be specified so we have to define these two 
+                # operators separately to enable that. 
+                (?<===|!=)            # Only match for equals and not equals 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)*   # release 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+ 
+                # You cannot use a wild card and a dev or local version 
+                # together so group them with a | and make them optional. 
+                (?: 
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release 
+                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local 
+                    | 
+                    \.\*  # Wild card syntax of .* 
+                )? 
+            ) 
+            | 
+            (?: 
+                # The compatible operator requires at least two digits in the 
+                # release segment. 
+                (?<=~=)               # Only match for the compatible operator 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *) 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release 
+            ) 
+            | 
+            (?: 
+                # All other operators only allow a sub set of what the 
+                # (non)equality operators do. Specifically they do not allow 
+                # local versions to be specified nor do they allow the prefix 
+                # matching wild cards. 
+                (?<!==|!=|~=)         # We have special cases for these 
+                                      # operators so we want to make sure they 
+                                      # don't match here. 
+ 
+                \s* 
+                v? 
+                (?:[0-9]+!)?          # epoch 
+                [0-9]+(?:\.[0-9]+)*   # release 
+                (?:                   # pre release 
+                    [-_\.]? 
+                    (a|b|c|rc|alpha|beta|pre|preview) 
+                    [-_\.]? 
+                    [0-9]* 
+                )? 
+                (?:                                   # post release 
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) 
+                )? 
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release 
+            ) 
+        ) 
+        """ 
+ 
     _regex = re.compile(r"^\s*" + _regex_str + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
-    _operators = {
-        "~=": "compatible",
-        "==": "equal",
-        "!=": "not_equal",
-        "<=": "less_than_equal",
-        ">=": "greater_than_equal",
-        "<": "less_than",
-        ">": "greater_than",
-        "===": "arbitrary",
-    }
-
-    @_require_version_compare
+ 
+    _operators = { 
+        "~=": "compatible", 
+        "==": "equal", 
+        "!=": "not_equal", 
+        "<=": "less_than_equal", 
+        ">=": "greater_than_equal", 
+        "<": "less_than", 
+        ">": "greater_than", 
+        "===": "arbitrary", 
+    } 
+ 
+    @_require_version_compare 
     def _compare_compatible(self, prospective: ParsedVersion, spec: str) -> bool:
 
-        # Compatible releases have an equivalent combination of >= and ==. That
-        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
-        # implement this in terms of the other specifiers instead of
-        # implementing it ourselves. The only thing we need to do is construct
-        # the other specifiers.
-
-        # We want everything but the last item in the version, but we want to
+        # Compatible releases have an equivalent combination of >= and ==. That 
+        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to 
+        # implement this in terms of the other specifiers instead of 
+        # implementing it ourselves. The only thing we need to do is construct 
+        # the other specifiers. 
+ 
+        # We want everything but the last item in the version, but we want to 
         # ignore suffix segments.
-        prefix = ".".join(
+        prefix = ".".join( 
             list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1]
-        )
-
-        # Add the prefix notation to the end of our string
-        prefix += ".*"
-
+        ) 
+ 
+        # Add the prefix notation to the end of our string 
+        prefix += ".*" 
+ 
         return self._get_operator(">=")(prospective, spec) and self._get_operator("==")(
             prospective, prefix
         )
-
-    @_require_version_compare
+ 
+    @_require_version_compare 
     def _compare_equal(self, prospective: ParsedVersion, spec: str) -> bool:
 
-        # We need special logic to handle prefix matching
-        if spec.endswith(".*"):
-            # In the case of prefix matching we want to ignore local segment.
-            prospective = Version(prospective.public)
-            # Split the spec out by dots, and pretend that there is an implicit
-            # dot in between a release segment and a pre-release segment.
+        # We need special logic to handle prefix matching 
+        if spec.endswith(".*"): 
+            # In the case of prefix matching we want to ignore local segment. 
+            prospective = Version(prospective.public) 
+            # Split the spec out by dots, and pretend that there is an implicit 
+            # dot in between a release segment and a pre-release segment. 
             split_spec = _version_split(spec[:-2])  # Remove the trailing .*
-
-            # Split the prospective version out by dots, and pretend that there
-            # is an implicit dot in between a release segment and a pre-release
-            # segment.
+ 
+            # Split the prospective version out by dots, and pretend that there 
+            # is an implicit dot in between a release segment and a pre-release 
+            # segment. 
             split_prospective = _version_split(str(prospective))
-
-            # Shorten the prospective version to be the same length as the spec
-            # so that we can determine if the specifier is a prefix of the
-            # prospective version or not.
+ 
+            # Shorten the prospective version to be the same length as the spec 
+            # so that we can determine if the specifier is a prefix of the 
+            # prospective version or not. 
             shortened_prospective = split_prospective[: len(split_spec)]
-
-            # Pad out our two sides with zeros so that they both equal the same
-            # length.
+ 
+            # Pad out our two sides with zeros so that they both equal the same 
+            # length. 
             padded_spec, padded_prospective = _pad_version(
                 split_spec, shortened_prospective
             )
 
             return padded_prospective == padded_spec
-        else:
-            # Convert our spec string into a Version
+        else: 
+            # Convert our spec string into a Version 
             spec_version = Version(spec)
-
-            # If the specifier does not have a local segment, then we want to
-            # act as if the prospective version also does not have a local
-            # segment.
+ 
+            # If the specifier does not have a local segment, then we want to 
+            # act as if the prospective version also does not have a local 
+            # segment. 
             if not spec_version.local:
-                prospective = Version(prospective.public)
-
+                prospective = Version(prospective.public) 
+ 
             return prospective == spec_version
-
-    @_require_version_compare
+ 
+    @_require_version_compare 
     def _compare_not_equal(self, prospective: ParsedVersion, spec: str) -> bool:
-        return not self._compare_equal(prospective, spec)
-
-    @_require_version_compare
+        return not self._compare_equal(prospective, spec) 
+ 
+    @_require_version_compare 
     def _compare_less_than_equal(self, prospective: ParsedVersion, spec: str) -> bool:
-
+ 
         # NB: Local version identifiers are NOT permitted in the version
         # specifier, so local version labels can be universally removed from
         # the prospective version.
         return Version(prospective.public) <= Version(spec)
 
-    @_require_version_compare
+    @_require_version_compare 
     def _compare_greater_than_equal(
         self, prospective: ParsedVersion, spec: str
     ) -> bool:
-
+ 
         # NB: Local version identifiers are NOT permitted in the version
         # specifier, so local version labels can be universally removed from
         # the prospective version.
         return Version(prospective.public) >= Version(spec)
 
-    @_require_version_compare
+    @_require_version_compare 
     def _compare_less_than(self, prospective: ParsedVersion, spec_str: str) -> bool:
 
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
+        # Convert our spec to a Version instance, since we'll want to work with 
+        # it as a version. 
         spec = Version(spec_str)
-
-        # Check to see if the prospective version is less than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective < spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a pre-release version, that we do not accept pre-release
-        # versions for the version mentioned in the specifier (e.g. <3.1 should
-        # not match 3.1.dev0, but should match 3.0.dev0).
-        if not spec.is_prerelease and prospective.is_prerelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # less than the spec version *and* it's not a pre-release of the same
-        # version in the spec.
-        return True
-
-    @_require_version_compare
+ 
+        # Check to see if the prospective version is less than the spec 
+        # version. If it's not we can short circuit and just return False now 
+        # instead of doing extra unneeded work. 
+        if not prospective < spec: 
+            return False 
+ 
+        # This special case is here so that, unless the specifier itself 
+        # includes is a pre-release version, that we do not accept pre-release 
+        # versions for the version mentioned in the specifier (e.g. <3.1 should 
+        # not match 3.1.dev0, but should match 3.0.dev0). 
+        if not spec.is_prerelease and prospective.is_prerelease: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # If we've gotten to here, it means that prospective version is both 
+        # less than the spec version *and* it's not a pre-release of the same 
+        # version in the spec. 
+        return True 
+ 
+    @_require_version_compare 
     def _compare_greater_than(self, prospective: ParsedVersion, spec_str: str) -> bool:
 
-        # Convert our spec to a Version instance, since we'll want to work with
-        # it as a version.
+        # Convert our spec to a Version instance, since we'll want to work with 
+        # it as a version. 
         spec = Version(spec_str)
-
-        # Check to see if the prospective version is greater than the spec
-        # version. If it's not we can short circuit and just return False now
-        # instead of doing extra unneeded work.
-        if not prospective > spec:
-            return False
-
-        # This special case is here so that, unless the specifier itself
-        # includes is a post-release version, that we do not accept
-        # post-release versions for the version mentioned in the specifier
-        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
-        if not spec.is_postrelease and prospective.is_postrelease:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # Ensure that we do not allow a local version of the version mentioned
+ 
+        # Check to see if the prospective version is greater than the spec 
+        # version. If it's not we can short circuit and just return False now 
+        # instead of doing extra unneeded work. 
+        if not prospective > spec: 
+            return False 
+ 
+        # This special case is here so that, unless the specifier itself 
+        # includes is a post-release version, that we do not accept 
+        # post-release versions for the version mentioned in the specifier 
+        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0). 
+        if not spec.is_postrelease and prospective.is_postrelease: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # Ensure that we do not allow a local version of the version mentioned 
         # in the specifier, which is technically greater than, to match.
-        if prospective.local is not None:
-            if Version(prospective.base_version) == Version(spec.base_version):
-                return False
-
-        # If we've gotten to here, it means that prospective version is both
-        # greater than the spec version *and* it's not a pre-release of the
-        # same version in the spec.
-        return True
-
+        if prospective.local is not None: 
+            if Version(prospective.base_version) == Version(spec.base_version): 
+                return False 
+ 
+        # If we've gotten to here, it means that prospective version is both 
+        # greater than the spec version *and* it's not a pre-release of the 
+        # same version in the spec. 
+        return True 
+ 
     def _compare_arbitrary(self, prospective: Version, spec: str) -> bool:
-        return str(prospective).lower() == str(spec).lower()
-
-    @property
+        return str(prospective).lower() == str(spec).lower() 
+ 
+    @property 
     def prereleases(self) -> bool:
 
-        # If there is an explicit prereleases set for this, then we'll just
-        # blindly use that.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # Look at all of our specifiers and determine if they are inclusive
-        # operators, and if they are if they are including an explicit
-        # prerelease.
-        operator, version = self._spec
-        if operator in ["==", ">=", "<=", "~=", "==="]:
-            # The == specifier can include a trailing .*, if it does we
-            # want to remove before parsing.
-            if operator == "==" and version.endswith(".*"):
-                version = version[:-2]
-
-            # Parse the version, and if it is a pre-release than this
-            # specifier allows pre-releases.
-            if parse(version).is_prerelease:
-                return True
-
-        return False
-
-    @prereleases.setter
+        # If there is an explicit prereleases set for this, then we'll just 
+        # blindly use that. 
+        if self._prereleases is not None: 
+            return self._prereleases 
+ 
+        # Look at all of our specifiers and determine if they are inclusive 
+        # operators, and if they are if they are including an explicit 
+        # prerelease. 
+        operator, version = self._spec 
+        if operator in ["==", ">=", "<=", "~=", "==="]: 
+            # The == specifier can include a trailing .*, if it does we 
+            # want to remove before parsing. 
+            if operator == "==" and version.endswith(".*"): 
+                version = version[:-2] 
+ 
+            # Parse the version, and if it is a pre-release than this 
+            # specifier allows pre-releases. 
+            if parse(version).is_prerelease: 
+                return True 
+ 
+        return False 
+ 
+    @prereleases.setter 
     def prereleases(self, value: bool) -> None:
-        self._prereleases = value
-
-
-_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
-
-
+        self._prereleases = value 
+ 
+ 
+_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$") 
+ 
+ 
 def _version_split(version: str) -> List[str]:
     result: List[str] = []
-    for item in version.split("."):
-        match = _prefix_regex.search(item)
-        if match:
-            result.extend(match.groups())
-        else:
-            result.append(item)
-    return result
-
-
+    for item in version.split("."): 
+        match = _prefix_regex.search(item) 
+        if match: 
+            result.extend(match.groups()) 
+        else: 
+            result.append(item) 
+    return result 
+ 
+ 
 def _is_not_suffix(segment: str) -> bool:
     return not any(
         segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post")
@@ -600,203 +600,203 @@ def _is_not_suffix(segment: str) -> bool:
 
 
 def _pad_version(left: List[str], right: List[str]) -> Tuple[List[str], List[str]]:
-    left_split, right_split = [], []
-
-    # Get the release segment of our versions
-    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
-    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
-
-    # Get the rest of our versions
+    left_split, right_split = [], [] 
+ 
+    # Get the release segment of our versions 
+    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left))) 
+    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right))) 
+ 
+    # Get the rest of our versions 
     left_split.append(left[len(left_split[0]) :])
     right_split.append(right[len(right_split[0]) :])
-
-    # Insert our padding
+ 
+    # Insert our padding 
     left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0])))
     right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0])))
-
+ 
     return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split)))
-
-
-class SpecifierSet(BaseSpecifier):
+ 
+ 
+class SpecifierSet(BaseSpecifier): 
     def __init__(
         self, specifiers: str = "", prereleases: Optional[bool] = None
     ) -> None:
-
+ 
         # Split on , to break each individual specifier into it's own item, and
-        # strip each item to remove leading/trailing whitespace.
+        # strip each item to remove leading/trailing whitespace. 
         split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
-
-        # Parsed each individual specifier, attempting first to make it a
-        # Specifier and falling back to a LegacySpecifier.
+ 
+        # Parsed each individual specifier, attempting first to make it a 
+        # Specifier and falling back to a LegacySpecifier. 
         parsed: Set[_IndividualSpecifier] = set()
         for specifier in split_specifiers:
-            try:
-                parsed.add(Specifier(specifier))
-            except InvalidSpecifier:
-                parsed.add(LegacySpecifier(specifier))
-
-        # Turn our parsed specifiers into a frozen set and save them for later.
-        self._specs = frozenset(parsed)
-
-        # Store our prereleases value so we can use it later to determine if
-        # we accept prereleases or not.
-        self._prereleases = prereleases
-
+            try: 
+                parsed.add(Specifier(specifier)) 
+            except InvalidSpecifier: 
+                parsed.add(LegacySpecifier(specifier)) 
+ 
+        # Turn our parsed specifiers into a frozen set and save them for later. 
+        self._specs = frozenset(parsed) 
+ 
+        # Store our prereleases value so we can use it later to determine if 
+        # we accept prereleases or not. 
+        self._prereleases = prereleases 
+ 
     def __repr__(self) -> str:
-        pre = (
+        pre = ( 
             f", prereleases={self.prereleases!r}"
-            if self._prereleases is not None
-            else ""
-        )
-
+            if self._prereleases is not None 
+            else "" 
+        ) 
+ 
         return f"<SpecifierSet({str(self)!r}{pre})>"
-
+ 
     def __str__(self) -> str:
-        return ",".join(sorted(str(s) for s in self._specs))
-
+        return ",".join(sorted(str(s) for s in self._specs)) 
+ 
     def __hash__(self) -> int:
-        return hash(self._specs)
-
+        return hash(self._specs) 
+ 
     def __and__(self, other: Union["SpecifierSet", str]) -> "SpecifierSet":
         if isinstance(other, str):
-            other = SpecifierSet(other)
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        specifier = SpecifierSet()
-        specifier._specs = frozenset(self._specs | other._specs)
-
-        if self._prereleases is None and other._prereleases is not None:
-            specifier._prereleases = other._prereleases
-        elif self._prereleases is not None and other._prereleases is None:
-            specifier._prereleases = self._prereleases
-        elif self._prereleases == other._prereleases:
-            specifier._prereleases = self._prereleases
-        else:
-            raise ValueError(
-                "Cannot combine SpecifierSets with True and False prerelease "
-                "overrides."
-            )
-
-        return specifier
-
+            other = SpecifierSet(other) 
+        elif not isinstance(other, SpecifierSet): 
+            return NotImplemented 
+ 
+        specifier = SpecifierSet() 
+        specifier._specs = frozenset(self._specs | other._specs) 
+ 
+        if self._prereleases is None and other._prereleases is not None: 
+            specifier._prereleases = other._prereleases 
+        elif self._prereleases is not None and other._prereleases is None: 
+            specifier._prereleases = self._prereleases 
+        elif self._prereleases == other._prereleases: 
+            specifier._prereleases = self._prereleases 
+        else: 
+            raise ValueError( 
+                "Cannot combine SpecifierSets with True and False prerelease " 
+                "overrides." 
+            ) 
+ 
+        return specifier 
+ 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, (str, _IndividualSpecifier)):
-            other = SpecifierSet(str(other))
-        elif not isinstance(other, SpecifierSet):
-            return NotImplemented
-
-        return self._specs == other._specs
-
+            other = SpecifierSet(str(other)) 
+        elif not isinstance(other, SpecifierSet): 
+            return NotImplemented 
+ 
+        return self._specs == other._specs 
+ 
     def __len__(self) -> int:
-        return len(self._specs)
-
+        return len(self._specs) 
+ 
     def __iter__(self) -> Iterator[_IndividualSpecifier]:
-        return iter(self._specs)
-
-    @property
+        return iter(self._specs) 
+ 
+    @property 
     def prereleases(self) -> Optional[bool]:
 
-        # If we have been given an explicit prerelease modifier, then we'll
-        # pass that through here.
-        if self._prereleases is not None:
-            return self._prereleases
-
-        # If we don't have any specifiers, and we don't have a forced value,
-        # then we'll just return None since we don't know if this should have
-        # pre-releases or not.
-        if not self._specs:
-            return None
-
-        # Otherwise we'll see if any of the given specifiers accept
-        # prereleases, if any of them do we'll return True, otherwise False.
-        return any(s.prereleases for s in self._specs)
-
-    @prereleases.setter
+        # If we have been given an explicit prerelease modifier, then we'll 
+        # pass that through here. 
+        if self._prereleases is not None: 
+            return self._prereleases 
+ 
+        # If we don't have any specifiers, and we don't have a forced value, 
+        # then we'll just return None since we don't know if this should have 
+        # pre-releases or not. 
+        if not self._specs: 
+            return None 
+ 
+        # Otherwise we'll see if any of the given specifiers accept 
+        # prereleases, if any of them do we'll return True, otherwise False. 
+        return any(s.prereleases for s in self._specs) 
+ 
+    @prereleases.setter 
     def prereleases(self, value: bool) -> None:
-        self._prereleases = value
-
+        self._prereleases = value 
+ 
     def __contains__(self, item: UnparsedVersion) -> bool:
-        return self.contains(item)
-
+        return self.contains(item) 
+ 
     def contains(
         self, item: UnparsedVersion, prereleases: Optional[bool] = None
     ) -> bool:
 
-        # Ensure that our item is a Version or LegacyVersion instance.
-        if not isinstance(item, (LegacyVersion, Version)):
-            item = parse(item)
-
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # We can determine if we're going to allow pre-releases by looking to
-        # see if any of the underlying items supports them. If none of them do
-        # and this item is a pre-release then we do not allow it and we can
-        # short circuit that here.
-        # Note: This means that 1.0.dev1 would not be contained in something
-        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
-        if not prereleases and item.is_prerelease:
-            return False
-
-        # We simply dispatch to the underlying specs here to make sure that the
-        # given version is contained within all of them.
-        # Note: This use of all() here means that an empty set of specifiers
-        #       will always return True, this is an explicit design decision.
+        # Ensure that our item is a Version or LegacyVersion instance. 
+        if not isinstance(item, (LegacyVersion, Version)): 
+            item = parse(item) 
+ 
+        # Determine if we're forcing a prerelease or not, if we're not forcing 
+        # one for this particular filter call, then we'll use whatever the 
+        # SpecifierSet thinks for whether or not we should support prereleases. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # We can determine if we're going to allow pre-releases by looking to 
+        # see if any of the underlying items supports them. If none of them do 
+        # and this item is a pre-release then we do not allow it and we can 
+        # short circuit that here. 
+        # Note: This means that 1.0.dev1 would not be contained in something 
+        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0 
+        if not prereleases and item.is_prerelease: 
+            return False 
+ 
+        # We simply dispatch to the underlying specs here to make sure that the 
+        # given version is contained within all of them. 
+        # Note: This use of all() here means that an empty set of specifiers 
+        #       will always return True, this is an explicit design decision. 
         return all(s.contains(item, prereleases=prereleases) for s in self._specs)
-
+ 
     def filter(
         self, iterable: Iterable[VersionTypeVar], prereleases: Optional[bool] = None
     ) -> Iterable[VersionTypeVar]:
 
-        # Determine if we're forcing a prerelease or not, if we're not forcing
-        # one for this particular filter call, then we'll use whatever the
-        # SpecifierSet thinks for whether or not we should support prereleases.
-        if prereleases is None:
-            prereleases = self.prereleases
-
-        # If we have any specifiers, then we want to wrap our iterable in the
-        # filter method for each one, this will act as a logical AND amongst
-        # each specifier.
-        if self._specs:
-            for spec in self._specs:
-                iterable = spec.filter(iterable, prereleases=bool(prereleases))
-            return iterable
-        # If we do not have any specifiers, then we need to have a rough filter
-        # which will filter out any pre-releases, unless there are no final
-        # releases, and which will filter out LegacyVersion in general.
-        else:
+        # Determine if we're forcing a prerelease or not, if we're not forcing 
+        # one for this particular filter call, then we'll use whatever the 
+        # SpecifierSet thinks for whether or not we should support prereleases. 
+        if prereleases is None: 
+            prereleases = self.prereleases 
+ 
+        # If we have any specifiers, then we want to wrap our iterable in the 
+        # filter method for each one, this will act as a logical AND amongst 
+        # each specifier. 
+        if self._specs: 
+            for spec in self._specs: 
+                iterable = spec.filter(iterable, prereleases=bool(prereleases)) 
+            return iterable 
+        # If we do not have any specifiers, then we need to have a rough filter 
+        # which will filter out any pre-releases, unless there are no final 
+        # releases, and which will filter out LegacyVersion in general. 
+        else: 
             filtered: List[VersionTypeVar] = []
             found_prereleases: List[VersionTypeVar] = []
-
+ 
             item: UnparsedVersion
             parsed_version: Union[Version, LegacyVersion]
 
-            for item in iterable:
-                # Ensure that we some kind of Version class for this item.
-                if not isinstance(item, (LegacyVersion, Version)):
-                    parsed_version = parse(item)
-                else:
-                    parsed_version = item
-
-                # Filter out any item which is parsed as a LegacyVersion
-                if isinstance(parsed_version, LegacyVersion):
-                    continue
-
-                # Store any item which is a pre-release for later unless we've
-                # already found a final version or we are accepting prereleases
-                if parsed_version.is_prerelease and not prereleases:
-                    if not filtered:
-                        found_prereleases.append(item)
-                else:
-                    filtered.append(item)
-
-            # If we've found no items except for pre-releases, then we'll go
-            # ahead and use the pre-releases
-            if not filtered and found_prereleases and prereleases is None:
-                return found_prereleases
-
-            return filtered
+            for item in iterable: 
+                # Ensure that we some kind of Version class for this item. 
+                if not isinstance(item, (LegacyVersion, Version)): 
+                    parsed_version = parse(item) 
+                else: 
+                    parsed_version = item 
+ 
+                # Filter out any item which is parsed as a LegacyVersion 
+                if isinstance(parsed_version, LegacyVersion): 
+                    continue 
+ 
+                # Store any item which is a pre-release for later unless we've 
+                # already found a final version or we are accepting prereleases 
+                if parsed_version.is_prerelease and not prereleases: 
+                    if not filtered: 
+                        found_prereleases.append(item) 
+                else: 
+                    filtered.append(item) 
+ 
+            # If we've found no items except for pre-releases, then we'll go 
+            # ahead and use the pre-releases 
+            if not filtered and found_prereleases and prereleases is None: 
+                return found_prereleases 
+ 
+            return filtered 
diff --git a/contrib/python/packaging/py3/packaging/utils.py b/contrib/python/packaging/py3/packaging/utils.py
index bab11b80c6..902d2ac31b 100644
--- a/contrib/python/packaging/py3/packaging/utils.py
+++ b/contrib/python/packaging/py3/packaging/utils.py
@@ -1,13 +1,13 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-import re
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+ 
+import re 
 from typing import FrozenSet, NewType, Tuple, Union, cast
-
+ 
 from .tags import Tag, parse_tag
 from .version import InvalidVersion, Version
-
+ 
 BuildTag = Union[Tuple[()], Tuple[int, str]]
 NormalizedName = NewType("NormalizedName", str)
 
@@ -24,13 +24,13 @@ class InvalidSdistFilename(ValueError):
     """
 
 
-_canonicalize_regex = re.compile(r"[-_.]+")
+_canonicalize_regex = re.compile(r"[-_.]+") 
 # PEP 427: The build number must start with a digit.
 _build_tag_regex = re.compile(r"(\d+)(.*)")
-
-
+ 
+ 
 def canonicalize_name(name: str) -> NormalizedName:
-    # This is taken from PEP 503.
+    # This is taken from PEP 503. 
     value = _canonicalize_regex.sub("-", name).lower()
     return cast(NormalizedName, value)
 
diff --git a/contrib/python/packaging/py3/packaging/version.py b/contrib/python/packaging/py3/packaging/version.py
index de9a09a4ed..faeab05164 100644
--- a/contrib/python/packaging/py3/packaging/version.py
+++ b/contrib/python/packaging/py3/packaging/version.py
@@ -1,17 +1,17 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-import collections
-import itertools
-import re
+# This file is dual licensed under the terms of the Apache License, Version 
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository 
+# for complete details. 
+ 
+import collections 
+import itertools 
+import re 
 import warnings
 from typing import Callable, Iterator, List, Optional, SupportsInt, Tuple, Union
-
+ 
 from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType
-
+ 
 __all__ = ["parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN"]
-
+ 
 InfiniteTypes = Union[InfinityType, NegativeInfinityType]
 PrePostDevType = Union[InfiniteTypes, Tuple[str, int]]
 SubLocalType = Union[InfiniteTypes, int, str]
@@ -33,81 +33,81 @@ LegacyCmpKey = Tuple[int, Tuple[str, ...]]
 VersionComparisonMethod = Callable[
     [Union[CmpKey, LegacyCmpKey], Union[CmpKey, LegacyCmpKey]], bool
 ]
-
-_Version = collections.namedtuple(
+ 
+_Version = collections.namedtuple( 
     "_Version", ["epoch", "release", "dev", "pre", "post", "local"]
-)
-
-
+) 
+ 
+ 
 def parse(version: str) -> Union["LegacyVersion", "Version"]:
-    """
-    Parse the given version string and return either a :class:`Version` object
-    or a :class:`LegacyVersion` object depending on if the given version is
-    a valid PEP 440 version or a legacy version.
-    """
-    try:
-        return Version(version)
-    except InvalidVersion:
-        return LegacyVersion(version)
-
-
-class InvalidVersion(ValueError):
-    """
-    An invalid version was found, users should refer to PEP 440.
-    """
-
-
+    """ 
+    Parse the given version string and return either a :class:`Version` object 
+    or a :class:`LegacyVersion` object depending on if the given version is 
+    a valid PEP 440 version or a legacy version. 
+    """ 
+    try: 
+        return Version(version) 
+    except InvalidVersion: 
+        return LegacyVersion(version) 
+ 
+ 
+class InvalidVersion(ValueError): 
+    """ 
+    An invalid version was found, users should refer to PEP 440. 
+    """ 
+ 
+ 
 class _BaseVersion:
     _key: Union[CmpKey, LegacyCmpKey]
-
+ 
     def __hash__(self) -> int:
-        return hash(self._key)
-
+        return hash(self._key) 
+ 
     # Please keep the duplicated `isinstance` check
     # in the six comparisons hereunder
     # unless you find a way to avoid adding overhead function calls.
     def __lt__(self, other: "_BaseVersion") -> bool:
         if not isinstance(other, _BaseVersion):
             return NotImplemented
-
+ 
         return self._key < other._key
 
     def __le__(self, other: "_BaseVersion") -> bool:
         if not isinstance(other, _BaseVersion):
             return NotImplemented
-
+ 
         return self._key <= other._key
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, _BaseVersion):
             return NotImplemented
-
+ 
         return self._key == other._key
 
     def __ge__(self, other: "_BaseVersion") -> bool:
         if not isinstance(other, _BaseVersion):
             return NotImplemented
-
+ 
         return self._key >= other._key
 
     def __gt__(self, other: "_BaseVersion") -> bool:
         if not isinstance(other, _BaseVersion):
             return NotImplemented
-
+ 
         return self._key > other._key
 
     def __ne__(self, other: object) -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-
+        if not isinstance(other, _BaseVersion): 
+            return NotImplemented 
+ 
         return self._key != other._key
-
-
-class LegacyVersion(_BaseVersion):
+ 
+ 
+class LegacyVersion(_BaseVersion): 
     def __init__(self, version: str) -> None:
-        self._version = str(version)
-        self._key = _legacy_cmpkey(self._version)
-
+        self._version = str(version) 
+        self._key = _legacy_cmpkey(self._version) 
+ 
         warnings.warn(
             "Creating a LegacyVersion has been deprecated and will be "
             "removed in the next major release",
@@ -115,20 +115,20 @@ class LegacyVersion(_BaseVersion):
         )
 
     def __str__(self) -> str:
-        return self._version
-
+        return self._version 
+ 
     def __repr__(self) -> str:
         return f"<LegacyVersion('{self}')>"
-
-    @property
+ 
+    @property 
     def public(self) -> str:
-        return self._version
-
-    @property
+        return self._version 
+ 
+    @property 
     def base_version(self) -> str:
-        return self._version
-
-    @property
+        return self._version 
+ 
+    @property 
     def epoch(self) -> int:
         return -1
 
@@ -150,175 +150,175 @@ class LegacyVersion(_BaseVersion):
 
     @property
     def local(self) -> None:
-        return None
-
-    @property
+        return None 
+ 
+    @property 
     def is_prerelease(self) -> bool:
-        return False
-
-    @property
+        return False 
+ 
+    @property 
     def is_postrelease(self) -> bool:
-        return False
-
+        return False 
+ 
     @property
     def is_devrelease(self) -> bool:
         return False
-
+ 
 
 _legacy_version_component_re = re.compile(r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE)
-
-_legacy_version_replacement_map = {
+ 
+_legacy_version_replacement_map = { 
     "pre": "c",
     "preview": "c",
     "-": "final-",
     "rc": "c",
     "dev": "@",
-}
-
-
+} 
+ 
+ 
 def _parse_version_parts(s: str) -> Iterator[str]:
-    for part in _legacy_version_component_re.split(s):
-        part = _legacy_version_replacement_map.get(part, part)
-
-        if not part or part == ".":
-            continue
-
-        if part[:1] in "0123456789":
-            # pad for numeric comparison
-            yield part.zfill(8)
-        else:
-            yield "*" + part
-
-    # ensure that alpha/beta/candidate are before final
-    yield "*final"
-
-
+    for part in _legacy_version_component_re.split(s): 
+        part = _legacy_version_replacement_map.get(part, part) 
+ 
+        if not part or part == ".": 
+            continue 
+ 
+        if part[:1] in "0123456789": 
+            # pad for numeric comparison 
+            yield part.zfill(8) 
+        else: 
+            yield "*" + part 
+ 
+    # ensure that alpha/beta/candidate are before final 
+    yield "*final" 
+ 
+ 
 def _legacy_cmpkey(version: str) -> LegacyCmpKey:
 
-    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch
-    # greater than or equal to 0. This will effectively put the LegacyVersion,
-    # which uses the defacto standard originally implemented by setuptools,
-    # as before all PEP 440 versions.
-    epoch = -1
-
-    # This scheme is taken from pkg_resources.parse_version setuptools prior to
-    # it's adoption of the packaging library.
+    # We hardcode an epoch of -1 here. A PEP 440 version can only have a epoch 
+    # greater than or equal to 0. This will effectively put the LegacyVersion, 
+    # which uses the defacto standard originally implemented by setuptools, 
+    # as before all PEP 440 versions. 
+    epoch = -1 
+ 
+    # This scheme is taken from pkg_resources.parse_version setuptools prior to 
+    # it's adoption of the packaging library. 
     parts: List[str] = []
-    for part in _parse_version_parts(version.lower()):
-        if part.startswith("*"):
-            # remove "-" before a prerelease tag
-            if part < "*final":
-                while parts and parts[-1] == "*final-":
-                    parts.pop()
-
-            # remove trailing zeros from each series of numeric parts
-            while parts and parts[-1] == "00000000":
-                parts.pop()
-
-        parts.append(part)
-
+    for part in _parse_version_parts(version.lower()): 
+        if part.startswith("*"): 
+            # remove "-" before a prerelease tag 
+            if part < "*final": 
+                while parts and parts[-1] == "*final-": 
+                    parts.pop() 
+ 
+            # remove trailing zeros from each series of numeric parts 
+            while parts and parts[-1] == "00000000": 
+                parts.pop() 
+ 
+        parts.append(part) 
+ 
     return epoch, tuple(parts)
-
-
-# Deliberately not anchored to the start and end of the string, to make it
-# easier for 3rd party code to reuse
-VERSION_PATTERN = r"""
-    v?
-    (?:
-        (?:(?P<epoch>[0-9]+)!)?                           # epoch
-        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
-        (?P<pre>                                          # pre-release
-            [-_\.]?
-            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
-            [-_\.]?
-            (?P<pre_n>[0-9]+)?
-        )?
-        (?P<post>                                         # post release
-            (?:-(?P<post_n1>[0-9]+))
-            |
-            (?:
-                [-_\.]?
-                (?P<post_l>post|rev|r)
-                [-_\.]?
-                (?P<post_n2>[0-9]+)?
-            )
-        )?
-        (?P<dev>                                          # dev release
-            [-_\.]?
-            (?P<dev_l>dev)
-            [-_\.]?
-            (?P<dev_n>[0-9]+)?
-        )?
-    )
-    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
-"""
-
-
-class Version(_BaseVersion):
-
+ 
+
+# Deliberately not anchored to the start and end of the string, to make it 
+# easier for 3rd party code to reuse 
+VERSION_PATTERN = r""" 
+    v? 
+    (?: 
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch 
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment 
+        (?P<pre>                                          # pre-release 
+            [-_\.]? 
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview)) 
+            [-_\.]? 
+            (?P<pre_n>[0-9]+)? 
+        )? 
+        (?P<post>                                         # post release 
+            (?:-(?P<post_n1>[0-9]+)) 
+            | 
+            (?: 
+                [-_\.]? 
+                (?P<post_l>post|rev|r) 
+                [-_\.]? 
+                (?P<post_n2>[0-9]+)? 
+            ) 
+        )? 
+        (?P<dev>                                          # dev release 
+            [-_\.]? 
+            (?P<dev_l>dev) 
+            [-_\.]? 
+            (?P<dev_n>[0-9]+)? 
+        )? 
+    ) 
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version 
+""" 
+ 
+ 
+class Version(_BaseVersion): 
+ 
     _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
-
+ 
     def __init__(self, version: str) -> None:
 
-        # Validate the version and parse it into pieces
-        match = self._regex.search(version)
-        if not match:
+        # Validate the version and parse it into pieces 
+        match = self._regex.search(version) 
+        if not match: 
             raise InvalidVersion(f"Invalid version: '{version}'")
-
-        # Store the parsed out pieces of the version
-        self._version = _Version(
-            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
-            release=tuple(int(i) for i in match.group("release").split(".")),
+ 
+        # Store the parsed out pieces of the version 
+        self._version = _Version( 
+            epoch=int(match.group("epoch")) if match.group("epoch") else 0, 
+            release=tuple(int(i) for i in match.group("release").split(".")), 
             pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
-            post=_parse_letter_version(
+            post=_parse_letter_version( 
                 match.group("post_l"), match.group("post_n1") or match.group("post_n2")
-            ),
+            ), 
             dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
-            local=_parse_local_version(match.group("local")),
-        )
-
-        # Generate a key which will be used for sorting
-        self._key = _cmpkey(
-            self._version.epoch,
-            self._version.release,
-            self._version.pre,
-            self._version.post,
-            self._version.dev,
-            self._version.local,
-        )
-
+            local=_parse_local_version(match.group("local")), 
+        ) 
+ 
+        # Generate a key which will be used for sorting 
+        self._key = _cmpkey( 
+            self._version.epoch, 
+            self._version.release, 
+            self._version.pre, 
+            self._version.post, 
+            self._version.dev, 
+            self._version.local, 
+        ) 
+ 
     def __repr__(self) -> str:
         return f"<Version('{self}')>"
-
+ 
     def __str__(self) -> str:
-        parts = []
-
-        # Epoch
+        parts = [] 
+ 
+        # Epoch 
         if self.epoch != 0:
             parts.append(f"{self.epoch}!")
-
-        # Release segment
+ 
+        # Release segment 
         parts.append(".".join(str(x) for x in self.release))
-
-        # Pre-release
+ 
+        # Pre-release 
         if self.pre is not None:
             parts.append("".join(str(x) for x in self.pre))
-
-        # Post-release
+ 
+        # Post-release 
         if self.post is not None:
             parts.append(f".post{self.post}")
-
-        # Development release
+ 
+        # Development release 
         if self.dev is not None:
             parts.append(f".dev{self.dev}")
-
-        # Local version segment
+ 
+        # Local version segment 
         if self.local is not None:
             parts.append(f"+{self.local}")
-
-        return "".join(parts)
-
-    @property
+ 
+        return "".join(parts) 
+ 
+    @property 
     def epoch(self) -> int:
         _epoch: int = self._version.epoch
         return _epoch
@@ -350,33 +350,33 @@ class Version(_BaseVersion):
 
     @property
     def public(self) -> str:
-        return str(self).split("+", 1)[0]
-
-    @property
+        return str(self).split("+", 1)[0] 
+ 
+    @property 
     def base_version(self) -> str:
-        parts = []
-
-        # Epoch
+        parts = [] 
+ 
+        # Epoch 
         if self.epoch != 0:
             parts.append(f"{self.epoch}!")
-
-        # Release segment
+ 
+        # Release segment 
         parts.append(".".join(str(x) for x in self.release))
-
-        return "".join(parts)
-
-    @property
+ 
+        return "".join(parts) 
+ 
+    @property 
     def is_prerelease(self) -> bool:
         return self.dev is not None or self.pre is not None
-
-    @property
+ 
+    @property 
     def is_postrelease(self) -> bool:
         return self.post is not None
-
+ 
     @property
     def is_devrelease(self) -> bool:
         return self.dev is not None
-
+ 
     @property
     def major(self) -> int:
         return self.release[0] if len(self.release) >= 1 else 0
@@ -394,53 +394,53 @@ def _parse_letter_version(
     letter: str, number: Union[str, bytes, SupportsInt]
 ) -> Optional[Tuple[str, int]]:
 
-    if letter:
-        # We consider there to be an implicit 0 in a pre-release if there is
-        # not a numeral associated with it.
-        if number is None:
-            number = 0
-
-        # We normalize any letters to their lower case form
-        letter = letter.lower()
-
-        # We consider some words to be alternate spellings of other words and
-        # in those cases we want to normalize the spellings to our preferred
-        # spelling.
-        if letter == "alpha":
-            letter = "a"
-        elif letter == "beta":
-            letter = "b"
-        elif letter in ["c", "pre", "preview"]:
-            letter = "rc"
-        elif letter in ["rev", "r"]:
-            letter = "post"
-
-        return letter, int(number)
-    if not letter and number:
-        # We assume if we are given a number, but we are not given a letter
-        # then this is using the implicit post release syntax (e.g. 1.0-1)
-        letter = "post"
-
-        return letter, int(number)
-
+    if letter: 
+        # We consider there to be an implicit 0 in a pre-release if there is 
+        # not a numeral associated with it. 
+        if number is None: 
+            number = 0 
+ 
+        # We normalize any letters to their lower case form 
+        letter = letter.lower() 
+ 
+        # We consider some words to be alternate spellings of other words and 
+        # in those cases we want to normalize the spellings to our preferred 
+        # spelling. 
+        if letter == "alpha": 
+            letter = "a" 
+        elif letter == "beta": 
+            letter = "b" 
+        elif letter in ["c", "pre", "preview"]: 
+            letter = "rc" 
+        elif letter in ["rev", "r"]: 
+            letter = "post" 
+ 
+        return letter, int(number) 
+    if not letter and number: 
+        # We assume if we are given a number, but we are not given a letter 
+        # then this is using the implicit post release syntax (e.g. 1.0-1) 
+        letter = "post" 
+ 
+        return letter, int(number) 
+ 
     return None
-
+ 
 
 _local_version_separators = re.compile(r"[\._-]")
-
-
+ 
+ 
 def _parse_local_version(local: str) -> Optional[LocalType]:
-    """
-    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
-    """
-    if local is not None:
-        return tuple(
-            part.lower() if not part.isdigit() else int(part)
+    """ 
+    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve"). 
+    """ 
+    if local is not None: 
+        return tuple( 
+            part.lower() if not part.isdigit() else int(part) 
             for part in _local_version_separators.split(local)
-        )
+        ) 
     return None
-
-
+ 
+ 
 def _cmpkey(
     epoch: int,
     release: Tuple[int, ...],
@@ -450,55 +450,55 @@ def _cmpkey(
     local: Optional[Tuple[SubLocalType]],
 ) -> CmpKey:
 
-    # When we compare a release version, we want to compare it with all of the
-    # trailing zeros removed. So we'll use a reverse the list, drop all the now
-    # leading zeros until we come to something non zero, then take the rest
-    # re-reverse it back into the correct order and make it a tuple and use
-    # that for our sorting key.
+    # When we compare a release version, we want to compare it with all of the 
+    # trailing zeros removed. So we'll use a reverse the list, drop all the now 
+    # leading zeros until we come to something non zero, then take the rest 
+    # re-reverse it back into the correct order and make it a tuple and use 
+    # that for our sorting key. 
     _release = tuple(
         reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
-    )
-
-    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
-    # We'll do this by abusing the pre segment, but we _only_ want to do this
-    # if there is not a pre or a post segment. If we have one of those then
-    # the normal sorting rules will handle this case correctly.
-    if pre is None and post is None and dev is not None:
+    ) 
+ 
+    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0. 
+    # We'll do this by abusing the pre segment, but we _only_ want to do this 
+    # if there is not a pre or a post segment. If we have one of those then 
+    # the normal sorting rules will handle this case correctly. 
+    if pre is None and post is None and dev is not None: 
         _pre: PrePostDevType = NegativeInfinity
-    # Versions without a pre-release (except as noted above) should sort after
-    # those with one.
-    elif pre is None:
+    # Versions without a pre-release (except as noted above) should sort after 
+    # those with one. 
+    elif pre is None: 
         _pre = Infinity
     else:
         _pre = pre
-
-    # Versions without a post segment should sort before those with one.
-    if post is None:
+ 
+    # Versions without a post segment should sort before those with one. 
+    if post is None: 
         _post: PrePostDevType = NegativeInfinity
-
+ 
     else:
         _post = post
 
-    # Versions without a development segment should sort after those with one.
-    if dev is None:
+    # Versions without a development segment should sort after those with one. 
+    if dev is None: 
         _dev: PrePostDevType = Infinity
-
+ 
     else:
         _dev = dev
 
-    if local is None:
-        # Versions without a local segment should sort before those with one.
+    if local is None: 
+        # Versions without a local segment should sort before those with one. 
         _local: LocalType = NegativeInfinity
-    else:
-        # Versions with a local segment need that segment parsed to implement
-        # the sorting rules in PEP440.
-        # - Alpha numeric segments sort before numeric segments
-        # - Alpha numeric segments sort lexicographically
-        # - Numeric segments sort numerically
-        # - Shorter versions sort before longer versions when the prefixes
-        #   match exactly
+    else: 
+        # Versions with a local segment need that segment parsed to implement 
+        # the sorting rules in PEP440. 
+        # - Alpha numeric segments sort before numeric segments 
+        # - Alpha numeric segments sort lexicographically 
+        # - Numeric segments sort numerically 
+        # - Shorter versions sort before longer versions when the prefixes 
+        #   match exactly 
         _local = tuple(
             (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
-        )
-
+        ) 
+ 
     return epoch, _release, _pre, _post, _dev, _local
diff --git a/contrib/python/packaging/py3/ya.make b/contrib/python/packaging/py3/ya.make
index de7f8cd056..60b96efe69 100644
--- a/contrib/python/packaging/py3/ya.make
+++ b/contrib/python/packaging/py3/ya.make
@@ -1,40 +1,40 @@
 # Generated by devtools/yamaker (pypi).
 
 PY3_LIBRARY()
-
+ 
 OWNER(
     orivej
     g:python-contrib
 )
 
 VERSION(21.3)
-
+ 
 LICENSE(
     BSD-2-Clause OR
     Apache-2.0
 )
 
-PEERDIR(
-    contrib/python/pyparsing
-)
-
+PEERDIR( 
+    contrib/python/pyparsing 
+) 
+ 
 NO_LINT()
 
-PY_SRCS(
-    TOP_LEVEL
+PY_SRCS( 
+    TOP_LEVEL 
     packaging/__about__.py
-    packaging/__init__.py
+    packaging/__init__.py 
     packaging/_manylinux.py
     packaging/_musllinux.py
-    packaging/_structures.py
-    packaging/markers.py
-    packaging/requirements.py
-    packaging/specifiers.py
+    packaging/_structures.py 
+    packaging/markers.py 
+    packaging/requirements.py 
+    packaging/specifiers.py 
     packaging/tags.py
-    packaging/utils.py
-    packaging/version.py
-)
-
+    packaging/utils.py 
+    packaging/version.py 
+) 
+ 
 RESOURCE_FILES(
     PREFIX contrib/python/packaging/py3/
     .dist-info/METADATA
@@ -42,4 +42,4 @@ RESOURCE_FILES(
     packaging/py.typed
 )
 
-END()
+END() 
diff --git a/contrib/python/packaging/ya.make b/contrib/python/packaging/ya.make
index 45549cf137..40d458c3c6 100644
--- a/contrib/python/packaging/ya.make
+++ b/contrib/python/packaging/ya.make
@@ -1,19 +1,19 @@
 PY23_LIBRARY()
-
+ 
 LICENSE(Service-Py23-Proxy)
 
 OWNER(g:python-contrib)
-
+ 
 IF (PYTHON2)
     PEERDIR(contrib/python/packaging/py2)
 ELSE()
     PEERDIR(contrib/python/packaging/py3)
 ENDIF()
-
+ 
 NO_LINT()
-
+ 
 END()
-
+ 
 RECURSE(
     py2
     py3