Add type hints to package

CHANGELOG.rst

@@ -1,6 +1,11 @@
 Changelog
 =========
 
+Version v31.0.0
+----------------
+
+- Raise instead of returning ``NotImplementedError`` in ``version_range.VersionRange`` methods. https://github.com/aboutcode-org/univers/pull/158
+
 Version v30.12.1
 ----------------
 

requirements-dev.txt

@@ -7,8 +7,7 @@ pytest==7.2.0
 pytest-forked==1.4.0
 pytest-xdist==3.2.0
 toml==0.10.2
-typing-extensions==3.10.0.2
+typing-extensions==4.1.0
 zipp==3.6.0
-black==22.3.0
 typed-ast==1.4.3
 pathspec==0.9.0

requirements.txt

@@ -1,5 +1,5 @@
 attrs==21.2.0
-packaging==21.0
+packaging==25.0
 pyparsing==2.4.7
 semantic-version==2.8.5
 semver==2.13.0

src/univers/arch.py

@@ -6,6 +6,8 @@
 #
 # Visit https://aboutcode.org and https://github.com/aboutcode-org/univers for support and download.
 
+from __future__ import annotations
+
 import re
 from itertools import zip_longest
 from typing import Dict

src/univers/conan/errors.py

@@ -5,26 +5,42 @@
 # Visit https://aboutcode.org and https://github.com/aboutcode-org/univers for support and download.
 
 """
-    Exceptions raised and handled in Conan
-    These exceptions are mapped between server (as an HTTP response) and client
-    through the REST API. When an error happens in server its translated to an HTTP
-    error code that its sent to client. Client reads the server code and raise the
-    matching exception.
+Exceptions raised and handled in Conan
+These exceptions are mapped between server (as an HTTP response) and client
+through the REST API. When an error happens in server its translated to an HTTP
+error code that its sent to client. Client reads the server code and raise the
+matching exception.
 
-    see return_plugin.py
+see return_plugin.py
 
 """
+from __future__ import annotations
+
 from contextlib import contextmanager
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from collections.abc import Iterator
+    from typing import Any
+    from typing import Callable
+
+    try:
+        from typing import Never
+    except ImportError:
+        from typing_extensions import Never
 
 
 @contextmanager
-def conanfile_remove_attr(conanfile, names, method):
+def conanfile_remove_attr(
+    conanfile: Any, names: Iterable[str], method: Callable[..., Any]
+) -> Iterator[Never]:
     """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 _prop(attr_name: str) -> property:
         def _m(_):
             raise ConanException(f"'self.{attr_name}' access in '{method}()' method is forbidden")
 
@@ -41,7 +57,7 @@ def _m(_):
 
 
 @contextmanager
-def conanfile_exception_formatter(conanfile_name, func_name):
+def conanfile_exception_formatter(conanfile_name: str, func_name: str) -> Iterator[Never]:
     """
     Decorator to throw an exception formatted with the line of the conanfile where the error ocurrs.
     """
@@ -74,7 +90,9 @@ def _raise_conanfile_exc(e):
         _raise_conanfile_exc(exc)
 
 
-def _format_conanfile_exception(scope, method, exception):
+def _format_conanfile_exception(
+    scope: str, method: Callable[..., Any], exception: BaseException
+) -> str:
     """
     It will iterate the traceback lines, when it finds that the source code is inside the users
     conanfile it "start recording" the messages, when the trace exits the conanfile we return
@@ -125,12 +143,12 @@ def __init__(self, *args, **kwargs):
         self.remote = kwargs.pop("remote", None)
         super(ConanException, self).__init__(*args, **kwargs)
 
-    def remote_message(self):
+    def remote_message(self) -> str:
         if self.remote:
             return " [Remote: {}]".format(self.remote.name)
         return ""
 
-    def __str__(self):
+    def __str__(self) -> str:
 
         msg = super(ConanException, self).__str__()
 
@@ -242,7 +260,7 @@ class UserInterfaceErrorException(RequestErrorException):
     pass
 
 
-EXCEPTION_CODE_MAPPING = {
+EXCEPTION_CODE_MAPPING: dict[ConanException, int] = {
     InternalErrorException: 500,
     RequestErrorException: 400,
     AuthenticationException: 401,

src/univers/conan/version.py

@@ -4,43 +4,52 @@
 #
 # Visit https://aboutcode.org and https://github.com/aboutcode-org/univers for support and download.
 
+from __future__ import annotations
+
 from functools import total_ordering
+from typing import TYPE_CHECKING
 
 from univers.conan.errors import ConanException
 
+if TYPE_CHECKING:
+    try:
+        from typing import Self
+    except ImportError:
+        from typing_extensions import Self
+
 
 @total_ordering
 class _VersionItem:
     """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):
+    def __init__(self, item: str | int | Self):
         try:
             self._v = int(item)
         except ValueError:
             self._v = item
 
     @property
-    def value(self):
+    def value(self) -> int:
         return self._v
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self._v)
 
-    def __add__(self, other):
+    def __add__(self, other: Self) -> int:
         # necessary for the "bump()" functionality. Other aritmetic operations are missing
         return self._v + other
 
-    def __eq__(self, other):
+    def __eq__(self, other: str | int | Self) -> bool:
         if not isinstance(other, _VersionItem):
             other = _VersionItem(other)
         return self._v == other._v
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self._v)
 
-    def __lt__(self, other):
+    def __lt__(self, other: str | int | Self) -> bool:
         """
         @type other: _VersionItem
         """
@@ -59,7 +68,7 @@ class Version:
     It is just a helper to parse "." or "-" and compare taking into account integers when possible
     """
 
-    def __init__(self, value):
+    def __init__(self, value: int | str | Self):
         value = str(value)
         self._value = value
 
@@ -85,7 +94,7 @@ def __init__(self, value):
             del items[-1]
         self._nonzero_items = tuple(items)
 
-    def bump(self, index):
+    def bump(self, index: int) -> Self:
         """
         :meta private:
             Bump the version
@@ -110,7 +119,7 @@ def bump(self, index):
         result = Version(v)
         return result
 
-    def upper_bound(self, index):
+    def upper_bound(self, index: int) -> Self:
         items = list(self._items[:index])
         try:
             items.append(self._items[index] + 1)
@@ -123,52 +132,52 @@ def upper_bound(self, index):
         return result
 
     @property
-    def pre(self):
+    def pre(self) -> Self | None:
         return self._pre
 
     @property
-    def build(self):
+    def build(self) -> Self | None:
         return self._build
 
     @property
-    def main(self):
+    def main(self) -> tuple[_VersionItem, ...]:
         return self._items
 
     @property
-    def major(self):
+    def major(self) -> _VersionItem | None:
         try:
             return self.main[0]
         except IndexError:
             return None
 
     @property
-    def minor(self):
+    def minor(self) -> _VersionItem | None:
         try:
             return self.main[1]
         except IndexError:
             return None
 
     @property
-    def patch(self):
+    def patch(self) -> _VersionItem | None:
         try:
             return self.main[2]
         except IndexError:
             return None
 
     @property
-    def micro(self):
+    def micro(self) -> _VersionItem | None:
         try:
             return self.main[3]
         except IndexError:
             return None
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self._value
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return self._value
 
-    def __eq__(self, other):
+    def __eq__(self, other: int | str | Self | None) -> bool:
         if other is None:
             return False
         if not isinstance(other, Version):
@@ -180,10 +189,10 @@ def __eq__(self, other):
             other._build,
         )
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash((self._nonzero_items, self._pre, self._build))
 
-    def __lt__(self, other):
+    def __lt__(self, other: int | str | Self | None) -> bool:
         if other is None:
             return False
         if not isinstance(other, Version):

src/univers/conan/version_range.py

@@ -4,6 +4,8 @@
 #
 # Visit https://aboutcode.org and https://github.com/aboutcode-org/univers for support and download.
 
+from __future__ import annotations
+
 from collections import namedtuple
 
 from univers.conan.errors import ConanException
@@ -13,7 +15,7 @@
 
 
 class _ConditionSet:
-    def __init__(self, expression, prerelease):
+    def __init__(self, expression: str, prerelease: bool):
         expressions = expression.split()
         self.prerelease = prerelease
         self.conditions = []
@@ -25,7 +27,7 @@ def __init__(self, expression, prerelease):
             self.conditions.extend(self._parse_expression(e))
 
     @staticmethod
-    def _parse_expression(expression):
+    def _parse_expression(expression: str) -> list[_Condition | ConanVersion]:
         if expression == "" or expression == "*":
             return [_Condition(">=", ConanVersion("0.0.0"))]
 
@@ -60,7 +62,7 @@ def first_non_zero(main):
         else:
             return [_Condition(operator, ConanVersion(version))]
 
-    def valid(self, version):
+    def valid(self, version: ConanVersion) -> bool:
         if version.pre:
             if not self.prerelease:
                 return False
@@ -84,7 +86,7 @@ def valid(self, version):
 
 
 class VersionRange:
-    def __init__(self, expression):
+    def __init__(self, expression: str):
         self._expression = expression
         tokens = expression.split(",")
         prereleases = None
@@ -97,10 +99,10 @@ def __init__(self, expression):
         for alternative in version_expr.split("||"):
             self.condition_sets.append(_ConditionSet(alternative, prereleases))
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self._expression
 
-    def __contains__(self, version):
+    def __contains__(self, version: ConanVersion) -> bool:
         assert isinstance(version, ConanVersion), type(version)
         for condition_set in self.condition_sets:
             if condition_set.valid(version):