chore: small linting

Author: mbdevpl

pyproject.toml

@@ -2,13 +2,18 @@
 requires = ['docutils', 'GitPython', 'packaging', 'semver', 'setuptools', 'wheel']
 
 [tool.pydocstyle]
-ignore = ['D102', 'D103', 'D105', 'D107', 'D203', 'D213', 'D406', 'D407', 'D412', 'D413']
+ignore = [
+    'D102', 'D103', 'D105', 'D107',
+    'D203', 'D213',
+    'D406', 'D407', 'D412', 'D413'
+]
 
 [tool.pylint.MASTER]
 load-plugins = [
+    'pylint.extensions.broad_try_clause',
     'pylint.extensions.mccabe',
-    'pylint.extensions.redefined_variable_type',
-    'pylint.extensions.broad_try_clause'
+    'pylint.extensions.no_self_use',
+    'pylint.extensions.redefined_variable_type'
 ]
 
 [tool.pylint.'MESSAGES CONTROL']

test/test_git.py

@@ -14,7 +14,6 @@
 
 
 class Tests(GitRepoTests):
-
     """Test suite for automated tests of generated git repositories.
 
     Each case is executed in a fresh empty repository.

test/test_query.py

@@ -22,6 +22,8 @@
 
 _LOG = logging.getLogger(__name__)
 
+IGNORED_FOLDER_NAMES = ['opencv']
+
 
 @contextlib.contextmanager
 def temporarily_set_logger_level(logger_name: str, level: int):
@@ -59,13 +61,16 @@ def test_example_count_checking(self):
 
     def _query_test_case(self, paths, query_function):
         for path in paths:
+            if any(_ in path.parts for _ in IGNORED_FOLDER_NAMES):
+                continue
             with self.subTest(path=path, query_function=query_function):
                 _LOG.debug('testing %s() on %s', query_function.__name__, path)
                 try:
                     version = query_function(path)
-                    _LOG.debug('%s: %s', path, version)
                 except ValueError:
                     _LOG.info('failed to get version from %s', path, exc_info=True)
+                else:
+                    _LOG.debug('%s: %s', path, version)
 
     def test_query_git_repo(self):
         self._check_examples_count('git repo', GIT_REPO_EXAMPLES)
@@ -76,7 +81,7 @@ def test_predict_caller_bad(self):
             with tempfile.NamedTemporaryFile(suffix='.py', dir=project_path_str,
                                              delete=False) as project_file:
                 project_file_path = pathlib.Path(project_file.name)
-            with project_file_path.open('a') as project_file:
+            with project_file_path.open('a', encoding='utf-8') as project_file:
                 project_file.write('from version_query.query import predict_caller\n\n\n'
                                    'def caller():\n    predict_caller()\n\n\ncaller()\n')
             sys.path.insert(0, project_path_str)
@@ -118,12 +123,12 @@ def test_query_pkg_info_bad(self):
         with self.assertRaises(ValueError):
             query_pkg_info(bad_file_path)
 
-        with bad_file_path.open('a') as bad_file:
+        with bad_file_path.open('a', encoding='utf-8') as bad_file:
             bad_file.write('blah blah blah')
         with self.assertRaises(ValueError):
             query_pkg_info(bad_file_path)
 
-        with bad_file_path.open('a') as bad_file:
+        with bad_file_path.open('a', encoding='utf-8') as bad_file:
             bad_file.write('Version: hello world')
         with self.assertRaises(ValueError):
             query_pkg_info(bad_file_path)

test/test_version.py

@@ -26,19 +26,18 @@ def test_from_str(self):
 
                 py_version = \
                     pkg_resources.parse_version(version_str)  # type: packaging.version.Version
+                # self.assertIsInstance(
+                #     py_version, packaging.version.Version, msg=(type(py_version), py_version))
                 _LOG.debug('packaging parsed version string %s into %s: %s',
                            repr(version_str), type(py_version), py_version)
 
                 try:
-                    sem_version = semver.parse(version_str)  # type: dict
-                    _LOG.debug('semver parsed version string %s into %s: %s',
-                               repr(version_str), type(sem_version), sem_version)
-                    sem_version_info = \
-                        semver.parse_version_info(version_str)  # type: semver.VersionInfo
-                    _LOG.debug('semver parsed version string %s into %s: %s',
-                               repr(version_str), type(sem_version_info), sem_version_info)
+                    sem_version = semver.VersionInfo.parse(version_str)  # type: semver.VersionInfo
                 except ValueError:
                     _LOG.debug('semver could not parse version string %s', repr(version_str))
+                else:
+                    _LOG.debug('semver parsed version string %s into %s: %s',
+                               repr(version_str), type(sem_version), sem_version)
 
                 self.assertEqual(Version.from_str(version_str).to_tuple(), version_tuple)
 
@@ -77,46 +76,44 @@ def test_from_sem_version(self):
             version_tuple = case_to_version_tuple(args, kwargs)
             with self.subTest(version_str=version_str, version_tuple=version_tuple):
                 try:
-                    sem_version = semver.parse(version_str)
+                    sem_version = semver.VersionInfo.parse(version_str)  # type: semver.VersionInfo
                 except ValueError:
-                    pass
+                    continue
                 else:
                     self.assertEqual(Version.from_sem_version(sem_version).to_tuple(),
                                      version_tuple, sem_version)
-                try:
-                    sem_version_info = semver.parse_version_info(version_str)
-                except ValueError:
-                    pass
-                else:
-                    self.assertEqual(Version.from_sem_version(sem_version_info).to_tuple(),
-                                     version_tuple, sem_version_info)
+                sem_version_dict = sem_version.to_dict()
+                self.assertEqual(Version.from_sem_version(sem_version_dict).to_tuple(),
+                                 version_tuple, sem_version_dict)
 
     def test_to_sem_version(self):
         for version_str, (args, kwargs) in COMPATIBLE_STR_CASES.items():
             version_tuple = case_to_version_tuple(args, kwargs)
             with self.subTest(version_str=version_str, version_tuple=version_tuple):
                 try:
-                    sem_version = semver.parse(version_str)
+                    sem_version = semver.VersionInfo.parse(version_str)
                 except ValueError:
                     continue
                 version = Version.from_str(version_str)
                 self.assertEqual(version.to_sem_version(), sem_version)
 
     def test_from_version(self):
-        for version_str, (args, kwargs) in INIT_CASES.items():
+        for version_str, args_kwargs_tuple in INIT_CASES.items():
+            args, kwargs = args_kwargs_tuple
             with self.subTest(args=args, kwargs=kwargs, version_str=version_str):
                 version = Version.from_str(version_str)
-                created_version = Version(*args, **dict(kwargs))
+                created_version = Version(*args, **kwargs)
                 self.assertIsInstance(created_version, Version)
                 self.assertEqual(version, created_version)
                 version_copy = Version.from_version(created_version)
                 self.assertEqual(version, version_copy)
                 self.assertEqual(version_copy, created_version)
 
     def test_init(self):
-        for version_str, (args, kwargs) in INIT_CASES.items():
+        for version_str, args_kwargs_tuple in INIT_CASES.items():
+            args, kwargs = args_kwargs_tuple
             with self.subTest(args=args, kwargs=kwargs, version_str=version_str):
-                version = Version(*args, **dict(kwargs))
+                version = Version(*args, **kwargs)
                 self.assertIsInstance(version, Version)
                 self.assertEqual(Version.from_str(version_str), version)
                 self.assertIsInstance(version.release, tuple)

version_query/git_query.py

@@ -41,20 +41,21 @@ def _git_version_tags(repo: git.Repo) -> t.Mapping[git.Tag, Version]:
 
 
 def _latest_git_version_tag_on_branches(
-        repo: git.Repo, assume_if_none: bool, commit: git.Commit, commit_distance: int,
-        skip_commits: t.Set[git.Commit]) -> t.Union[int, t.Tuple[
-            git.Commit, t.Optional[git.TagReference], t.Optional[Version], int]]:
+        repo: git.Repo, assume_if_none: bool, commit: git.objects.Commit, commit_distance: int,
+        skip_commits: t.Set[git.objects.Commit]) -> t.Union[int, t.Tuple[
+            t.Optional[git.objects.Commit], t.Optional[git.TagReference], t.Optional[Version],
+            int]]:
     _LOG.log(logging.NOTSET, 'entering %i branches...', len(commit.parents))
     results = []
     main_commit_distance = None
     for parent in commit.parents:
         try:
             result = _latest_git_version_tag(
                 repo, assume_if_none, parent, commit_distance, skip_commits)
-            if main_commit_distance is None:
-                main_commit_distance = result[3]
         except ValueError:
             continue
+        if main_commit_distance is None:
+            main_commit_distance = result[3]
         if result[2] is not None:
             results.append(result)
     if not results:
@@ -72,17 +73,17 @@ def _latest_git_version_tag_on_branches(
 
 
 def _latest_git_version_tag(
-        repo: git.Repo, assume_if_none: bool = False, base_commit: git.Commit = None,
-        commit_distance: int = 0, skip_commits: t.Set[git.Commit] = None) -> t.Tuple[
-            git.Commit, t.Optional[git.TagReference], t.Optional[Version], int]:
-    """Retrun (commit, tag at that commit if any, latest version, distance from the version)."""
+        repo: git.Repo, assume_if_none: bool = False, base_commit: git.objects.Commit = None,
+        commit_distance: int = 0, skip_commits: t.Set[git.objects.Commit] = None) -> t.Tuple[
+            t.Optional[git.objects.Commit], t.Optional[git.TagReference], t.Optional[Version], int]:
+    """Return (commit, tag at that commit if any, latest version, distance from the version)."""
     version_tags = _git_version_tags(repo)
-    version_tag_commits: t.Dict[git.Commit, set] = {}
+    version_tag_commits: t.Dict[git.objects.Commit, set] = {}
     for tag, version in version_tags.items():
-        commit = tag.commit
-        if commit not in version_tag_commits:
-            version_tag_commits[commit] = set()
-        version_tag_commits[commit].add(tag)
+        _commit = tag.commit
+        if _commit not in version_tag_commits:
+            version_tag_commits[_commit] = set()
+        version_tag_commits[_commit].add(tag)
     current_version_tags = {}
     commit = None
     if skip_commits is None:
@@ -120,7 +121,8 @@ def _latest_git_version_tag(
 
 
 def _upcoming_git_version_tag(repo: git.Repo, ignore_untracked_files: bool = True) -> t.Tuple[
-        git.Commit, t.Optional[git.TagReference], Version, int, bool]:
+        t.Optional[git.objects.Commit], t.Optional[git.TagReference], t.Optional[Version], int,
+        bool]:
     commit, tag, version, commit_distance = _latest_git_version_tag(repo, True)
     is_repo_dirty = repo.is_dirty(untracked_files=not ignore_untracked_files)
     return commit, tag, version, commit_distance, is_repo_dirty
@@ -131,13 +133,16 @@ def query_git_repo(repo_path: pathlib.Path, search_parent_directories: bool = Tr
     _LOG.debug('looking for git repository in "%s"', repo_path)
     repo = git.Repo(str(repo_path), search_parent_directories=search_parent_directories)
     _LOG.debug('found git repository in "%s"', repo.working_dir)
-    return _latest_git_version_tag(repo)[2]
+    version = _latest_git_version_tag(repo)[2]
+    assert isinstance(version, Version), version
+    return version
 
 
 def predict_git_repo(repo_path: pathlib.Path, search_parent_directories: bool = True) -> Version:
     """Predict version from tags, commit history and index status of git repository."""
     repo = git.Repo(str(repo_path), search_parent_directories=search_parent_directories)
     version, commit_distance, is_repo_dirty = _upcoming_git_version_tag(repo)[2:]
+    assert isinstance(version, Version), version
     if commit_distance > 0:
         version.devel_increment(commit_distance)
         version.local = (repo.head.commit.hexsha[:8],)

version_query/version.py

@@ -558,8 +558,8 @@ def to_dict(self) -> dict:
     def to_py_version(self) -> packaging.version.Version:
         return packaging.version.Version(self.to_str())
 
-    def to_sem_version(self) -> dict:
-        return semver.parse(self.to_str())
+    def to_sem_version(self) -> semver.VersionInfo:
+        return semver.VersionInfo.parse(self.to_str())
 
     def __repr__(self):
         fields = ', '.join(f'{field[1:]}: {repr(value)}' for field, value in vars(self).items())