Fix formatting errors

Signed-off-by: Tushar Goel <tushar.goel.dav@gmail.com>

Author: TG1999

src/univers/conan/errors.py

@@ -13,18 +13,19 @@
 
 @contextmanager
 def conanfile_remove_attr(conanfile, names, method):
-    """ remove some self.xxxx attribute from the class, so it raises an exception if used
+    """remove some self.xxxx attribute from the class, so it raises an exception if used
     within a given conanfile method
     """
     original_class = type(conanfile)
 
     def _prop(attr_name):
         def _m(_):
             raise ConanException(f"'self.{attr_name}' access in '{method}()' method is forbidden")
+
         return property(_m)
 
     try:
-        new_class = type(original_class.__name__, (original_class, ), {})
+        new_class = type(original_class.__name__, (original_class,), {})
         conanfile.__class__ = new_class
         for name in names:
             setattr(new_class, name, _prop(name))
@@ -40,9 +41,12 @@ def conanfile_exception_formatter(conanfile_name, func_name):
     """
 
     def _raise_conanfile_exc(e):
-        from conan.api.output import LEVEL_DEBUG, conan_output_level
+        from conan.api.output import LEVEL_DEBUG
+        from conan.api.output import conan_output_level
+
         if conan_output_level <= LEVEL_DEBUG:
             import traceback
+
             raise ConanExceptionInUserConanfileMethod(traceback.format_exc())
         m = _format_conanfile_exception(conanfile_name, func_name, e)
         raise ConanExceptionInUserConanfileMethod(m)
@@ -54,12 +58,17 @@ def _raise_conanfile_exc(e):
         msg = "{}: Invalid configuration: {}".format(str(conanfile_name), exc)
         raise ConanInvalidConfiguration(msg)
     except AttributeError as exc:
-        list_methods = [m for m in dir(list) if not m.startswith('__')]
-        if "NoneType" in str(exc) and func_name in ['layout', 'package_info'] and \
-            any(method in str(exc) for method in list_methods):
-            raise ConanException("{}: {}. No default values are set for components. You are probably "
-                                 "trying to manipulate a component attribute in the '{}' method "
-                                 "without defining it previously".format(str(conanfile_name), exc, func_name))
+        list_methods = [m for m in dir(list) if not m.startswith("__")]
+        if (
+            "NoneType" in str(exc)
+            and func_name in ["layout", "package_info"]
+            and any(method in str(exc) for method in list_methods)
+        ):
+            raise ConanException(
+                "{}: {}. No default values are set for components. You are probably "
+                "trying to manipulate a component attribute in the '{}' method "
+                "without defining it previously".format(str(conanfile_name), exc, func_name)
+            )
         else:
             _raise_conanfile_exc(exc)
     except Exception as exc:
@@ -74,6 +83,7 @@ def _format_conanfile_exception(scope, method, exception):
     """
     import sys
     import traceback
+
     try:
         conanfile_reached = False
         tb = sys.exc_info()[2]
@@ -91,8 +101,11 @@ def _format_conanfile_exception(scope, method, exception):
                     msg = "%s: Error in %s() method" % (scope, method)
                     msg += ", line %d\n\t%s" % (line, contents)
                 else:
-                    msg = ("while calling '%s', line %d\n\t%s" % (name, line, contents)
-                           if line else "\n\t%s" % contents)
+                    msg = (
+                        "while calling '%s', line %d\n\t%s" % (name, line, contents)
+                        if line
+                        else "\n\t%s" % contents
+                    )
                 content_lines.append(msg)
                 conanfile_reached = True
             index += 1
@@ -105,8 +118,9 @@ def _format_conanfile_exception(scope, method, exception):
 
 class ConanException(Exception):
     """
-         Generic conans exception
+    Generic conans exception
     """
+
     def __init__(self, *args, **kwargs):
         self.info = None
         self.remote = kwargs.pop("remote", None)
@@ -119,6 +133,7 @@ def remote_message(self):
 
     def __str__(self):
         from conans.util.files import exception_message_safe
+
         msg = super(ConanException, self).__str__()
         if self.remote:
             return "{}.{}".format(exception_message_safe(msg), self.remote_message())
@@ -127,18 +142,20 @@ def __str__(self):
 
 
 class ConanReferenceDoesNotExistInDB(ConanException):
-    """ Reference does not exist in cache db """
+    """Reference does not exist in cache db"""
+
     pass
 
 
 class ConanReferenceAlreadyExistsInDB(ConanException):
-    """ Reference already exists in cache db """
+    """Reference already exists in cache db"""
+
     pass
 
 
 class NoRemoteAvailable(ConanException):
-    """ No default remote configured or the specified remote do not exists
-    """
+    """No default remote configured or the specified remote do not exists"""
+
     pass
 
 
@@ -162,6 +179,7 @@ class ConanInvalidConfiguration(ConanExceptionInUserConanfileMethod):
     """
     This binary, for the requested configuration and package-id cannot be built
     """
+
     pass
 
 
@@ -172,35 +190,39 @@ class ConanMigrationError(ConanException):
 # Remote exceptions #
 class InternalErrorException(ConanException):
     """
-         Generic 500 error
+    Generic 500 error
     """
+
     pass
 
 
 class RequestErrorException(ConanException):
     """
-         Generic 400 error
+    Generic 400 error
     """
+
     pass
 
 
 class AuthenticationException(ConanException):  # 401
     """
-        401 error
+    401 error
     """
+
     pass
 
 
 class ForbiddenException(ConanException):  # 403
     """
-        403 error
+    403 error
     """
+
     pass
 
 
 class NotFoundException(ConanException):  # 404
     """
-        404 error
+    404 error
     """
 
     def __init__(self, *args, **kwargs):
@@ -209,10 +231,12 @@ def __init__(self, *args, **kwargs):
 
 
 class RecipeNotFoundException(NotFoundException):
-
     def __init__(self, ref, remote=None):
         from conans.model.recipe_ref import RecipeReference
-        assert isinstance(ref, RecipeReference), "RecipeNotFoundException requires a RecipeReference"
+
+        assert isinstance(
+            ref, RecipeReference
+        ), "RecipeNotFoundException requires a RecipeReference"
         self.ref = ref
         super(RecipeNotFoundException, self).__init__(remote=remote)
 
@@ -222,31 +246,35 @@ def __str__(self):
 
 
 class PackageNotFoundException(NotFoundException):
-
     def __init__(self, pref, remote=None):
         from conans.model.package_ref import PkgReference
+
         assert isinstance(pref, PkgReference), "PackageNotFoundException requires a PkgReference"
         self.pref = pref
 
         super(PackageNotFoundException, self).__init__(remote=remote)
 
     def __str__(self):
-        return "Binary package not found: '{}'{}".format(self.pref.repr_notime(),
-                                                         self.remote_message())
+        return "Binary package not found: '{}'{}".format(
+            self.pref.repr_notime(), self.remote_message()
+        )
 
 
 class UserInterfaceErrorException(RequestErrorException):
     """
-        420 error
+    420 error
     """
+
     pass
 
 
-EXCEPTION_CODE_MAPPING = {InternalErrorException: 500,
-                          RequestErrorException: 400,
-                          AuthenticationException: 401,
-                          ForbiddenException: 403,
-                          NotFoundException: 404,
-                          RecipeNotFoundException: 404,
-                          PackageNotFoundException: 404,
-                          UserInterfaceErrorException: 420}
+EXCEPTION_CODE_MAPPING = {
+    InternalErrorException: 500,
+    RequestErrorException: 400,
+    AuthenticationException: 401,
+    ForbiddenException: 403,
+    NotFoundException: 404,
+    RecipeNotFoundException: 404,
+    PackageNotFoundException: 404,
+    UserInterfaceErrorException: 420,
+}

src/univers/conan/version.py

@@ -5,9 +5,10 @@
 
 @total_ordering
 class _VersionItem:
-    """ a single "digit" in a version, like X.Y.Z all X and Y and Z are VersionItems
+    """a single "digit" in a version, like X.Y.Z all X and Y and Z are VersionItems
     They can be int or strings
     """
+
     def __init__(self, item):
         try:
             self._v = int(item)
@@ -51,6 +52,7 @@ class Version:
     This is NOT an implementation of semver, as users may use any pattern in their versions.
     It is just a helper to parse "." or "-" and compare taking into account integers when possible
     """
+
     def __init__(self, value):
         value = str(value)
         self._value = value
@@ -93,7 +95,7 @@ def bump(self, index):
         # better not make it public yet, keep it internal
         items = list(self._items[:index])
         try:
-            items.append(self._items[index]+1)
+            items.append(self._items[index] + 1)
         except TypeError:
             raise ConanException(f"Cannot bump '{self._value} version index {index}, not an int")
         items.extend([0] * (len(items) - index - 1))
@@ -166,8 +168,11 @@ def __eq__(self, other):
         if not isinstance(other, Version):
             other = Version(other)
 
-        return (self._nonzero_items, self._pre, self._build) ==\
-               (other._nonzero_items, other._pre, other._build)
+        return (self._nonzero_items, self._pre, self._build) == (
+            other._nonzero_items,
+            other._pre,
+            other._build,
+        )
 
     def __hash__(self):
         return hash((self._nonzero_items, self._pre, self._build))
@@ -180,16 +185,23 @@ def __lt__(self, other):
 
         if self._pre:
             if other._pre:  # both are pre-releases
-                return (self._nonzero_items, self._pre, self._build) < \
-                       (other._nonzero_items, other._pre, other._build)
+                return (self._nonzero_items, self._pre, self._build) < (
+                    other._nonzero_items,
+                    other._pre,
+                    other._build,
+                )
             else:  # Left hand is pre-release, right side is regular
-                if self._nonzero_items == other._nonzero_items:  # Problem only happens if both equal
+                if (
+                    self._nonzero_items == other._nonzero_items
+                ):  # Problem only happens if both equal
                     return True
                 else:
                     return self._nonzero_items < other._nonzero_items
         else:
             if other._pre:  # Left hand is regular, right side is pre-release
-                if self._nonzero_items == other._nonzero_items:  # Problem only happens if both equal
+                if (
+                    self._nonzero_items == other._nonzero_items
+                ):  # Problem only happens if both equal
                     return False
                 else:
                     return self._nonzero_items < other._nonzero_items

src/univers/conan/version_range.py

@@ -3,12 +3,10 @@
 from univers.conan.errors import ConanException
 from univers.conan.version import Version
 
-
 _Condition = namedtuple("_Condition", ["operator", "version"])
 
 
 class _ConditionSet:
-
     def __init__(self, expression, prerelease):
         expressions = expression.split()
         self.prerelease = prerelease

tests/test_conan_version_bump.py

@@ -3,11 +3,11 @@
 from univers.conan.version import Version
 
 values = [
-    ['1.0.0',       0, "2.0.0"],
-    ['1.1.0',       0, "2.0.0"],
-    ['1.1.1-pre',   0, "2.0.0"],
-    ['1.1.1',       1, "1.2.0"],
-    ['1.1.1',       2, "1.1.2"],
+    ["1.0.0", 0, "2.0.0"],
+    ["1.1.0", 0, "2.0.0"],
+    ["1.1.1-pre", 0, "2.0.0"],
+    ["1.1.1", 1, "1.2.0"],
+    ["1.1.1", 2, "1.1.2"],
 ]