refactored and added some type annotations, less mypy errors

Author: mbdevpl

test/examples.py

@@ -69,7 +69,7 @@ def _remove_version_suffixes(path: pathlib.Path) -> t.Optional[pathlib.Path]:
 
 KWARG_NAMES = ('major', 'minor', 'patch', 'pre_release', 'local')
 
-INIT_CASES = {
+INIT_CASES: t.Dict[str, t.Tuple[tuple, dict]] = {
     '1': ((1,), {}),
     '1.0': ((1, 0), {}),
     '1.0.0': ((1, 0, 0), {}),
@@ -79,7 +79,7 @@ def _remove_version_suffixes(path: pathlib.Path) -> t.Optional[pathlib.Path]:
     '1.0.0.rc3+local': ((1, 0, 0, ('.', 'rc', 3), 'local'), {}),
     '1.0.0.rc4+local': ((1, 0, 0, ('.', 'rc', 4), ('local',)), {})}
 
-BAD_INIT_CASES = {
+BAD_INIT_CASES: t.Dict[t.Tuple[tuple, tuple], t.Type[Exception]] = {
     (('spam',), ()): TypeError,
     ((-1,), ()): ValueError,
     ((1, 'ham'), ()): TypeError,

version_query/version.py

@@ -51,14 +51,20 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
     @classmethod
     def _parse_release_str(cls, release: str) -> tuple:
         match = cls._pattern_release.fullmatch(release)
-        major = match.group('major')
-        major = int(major)
-        minor = match.group('minor')
-        if minor is not None:
-            minor = int(minor)
-        patch = match.group('patch')
-        if patch is not None:
-            patch = int(patch)
+        assert match is not None
+        major_match = match.group('major')
+        assert major_match is not None
+        major = int(major_match)
+        minor_match = match.group('minor')
+        if minor_match is not None:
+            minor = int(minor_match)
+        else:
+            minor = None
+        patch_match = match.group('patch')
+        if patch_match is not None:
+            patch = int(patch_match)
+        else:
+            patch = None
         return major, minor, patch
 
     _re_pre_separator = rf'(?P<preseparator>{_re_sep})'
@@ -71,16 +77,20 @@ def _parse_release_str(cls, release: str) -> tuple:
     _pattern_pre_release_check = re.compile(rf'(?:{_re_pre_release_parts})+')
 
     @classmethod
-    def _parse_pre_release_str(cls, pre_release: str) -> tuple:
+    def _parse_pre_release_str(cls, pre_release: str) -> t.Sequence[
+            t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]]:
         parts = cls._pattern_pre_release.findall(pre_release)
         _LOG.debug('parsed pre-release string %s into %s',
                    repr(pre_release), parts)
         tuples = []
         for part in parts:
             match = cls._pattern_pre_release_part.fullmatch(part)
-            pre_patch = match.group('prepatch')
-            if pre_patch is not None:
-                pre_patch = int(pre_patch)
+            assert match is not None
+            pre_patch_match = match.group('prepatch')
+            if pre_patch_match is not None:
+                pre_patch = int(pre_patch_match)
+            else:
+                pre_patch = None
             tuples.append((match.group('preseparator'), match.group('pretype'), pre_patch))
         return tuples
 
@@ -92,6 +102,7 @@ def _parse_pre_release_str(cls, pre_release: str) -> tuple:
     @classmethod
     def _parse_local_str(cls, local: str) -> tuple:
         match = cls._pattern_local.fullmatch(local)
+        assert match is not None
         return tuple([_ for _ in match.groups() if _ is not None])
 
     _re_release = r'(?P<release>{n}(?:\.{n})?(?:\.{n})?)'.format(n=_re_number)
@@ -105,7 +116,7 @@ def _parse_local_str(cls, local: str) -> tuple:
     @classmethod
     def from_str(cls, version_str: str):
         """Create version from string."""
-        match = cls._pattern_version.fullmatch(version_str)  # type: t.Match[str]
+        match = cls._pattern_version.fullmatch(version_str)  # type: t.Optional[t.Match[str]]
         if match is None:
             raise ValueError('version string {} is invalid'.format(repr(version_str)))
         _LOG.debug('version_query parsed version string %s into %s: %s %s',
@@ -137,8 +148,10 @@ def from_py_version(cls, py_version: packaging.version.Version):
         ver = py_version._version
         major, minor, patch = [ver.release[i] if len(ver.release) > i
                                else None for i in range(3)]
-        pre_release = None
+        pre_release: t.Optional[t.Sequence[
+            t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]]] = None
         local = None
+        pre_ver: t.Optional[t.Tuple[None, int]]
         if len(ver.release) == 4:
             pre_ver = (None, ver.release[3])
         elif len(ver.release) > 4:
@@ -155,8 +168,8 @@ def from_py_version(cls, py_version: packaging.version.Version):
         elif ver.pre:
             pre_ver = ver.pre
         if pre_ver:
-            pre_release = [('.',) + tuple(pre_ver[i] if pre_ver and len(pre_ver) > i else None
-                                          for i in range(2))]
+            pre_release = [('.', pre_ver[0] if len(pre_ver) > 0 else None,
+                            pre_ver[1] if len(pre_ver) > 1 else None)]
         if ver.local:
             local = tuple(itertools.chain.from_iterable(
                 (dot, str(_)) for dot, _ in zip('.' * len(ver.local), ver.local)))[1:]
@@ -190,9 +203,9 @@ def __init__(
             pre_release: t.Sequence[
                 t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]] = None,
             local: t.Union[str, tuple] = None):
-        self._major = None
-        self._minor = None
-        self._patch = None
+        self._major: t.Optional[int] = None
+        self._minor: t.Optional[int] = None
+        self._patch: t.Optional[int] = None
         self._pre_release = None
         self._local = None
 
@@ -225,8 +238,9 @@ def __init__(
             local = (local,)
         self.local = local
 
-    def _get_pre_release_from_args(self, args) -> t.Tuple[list, int]:
-        pre_release = []
+    def _get_pre_release_from_args(self, args) -> t.Tuple[
+            t.Sequence[t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]], int]:
+        pre_release: t.List[t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]] = []
         consumed_args = 0
         if args and isinstance(args[0], tuple):
             for i, arg in enumerate(args):
@@ -242,7 +256,7 @@ def _get_pre_release_from_args(self, args) -> t.Tuple[list, int]:
                                  ' must be a 3-tuple'
                                  .format(arg, i, args, repr(self)))
         else:
-            accumulated = []
+            accumulated: t.List[t.Union[int, str]] = []
             for i, arg in enumerate(args):
                 if not accumulated:
                     if arg in (None, '.', '-'):
@@ -261,6 +275,7 @@ def _get_pre_release_from_args(self, args) -> t.Tuple[list, int]:
 
     @property
     def release(self) -> t.Tuple[int, t.Optional[int], t.Optional[int]]:
+        assert self._major is not None
         return self._major, self._minor, self._patch
 
     @release.setter
@@ -301,7 +316,7 @@ def release(self, release: t.Tuple[int, t.Optional[int], t.Optional[int]]):
 
     @property
     def pre_release(self) -> t.Optional[
-            t.List[t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]]]:
+            t.Sequence[t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]]]:
         """Pre-release version component."""
         if self._pre_release is None:
             return None