Add typing

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

Author: TG1999

src/python_inspector/resolution.py

@@ -10,26 +10,33 @@
 import operator
 import os
 import tarfile
+from typing import Dict
 from typing import List
 from typing import NamedTuple
 from typing import Sequence
+from typing import Union
 from zipfile import ZipFile
 
-import packaging.requirements
 import packaging.utils
-import packaging.version
 import requests
 from packageurl import PackageURL
 from packaging.requirements import Requirement
+from packaging.version import LegacyVersion
+from packaging.version import Version
+from packaging.version import parse as parse_version
 from resolvelib import AbstractProvider
 from resolvelib import Resolver
 from resolvelib.reporters import BaseReporter
 
+from _packagedcode.models import DependentPackage
+from _packagedcode.pypi import BasePypiHandler
 from _packagedcode.pypi import PipRequirementsFileHandler
 from _packagedcode.pypi import PypiWheelHandler
 from _packagedcode.pypi import PythonSetupPyHandler
 from _packagedcode.pypi import SetupCfgHandler
 from python_inspector import utils_pypi
+from python_inspector.utils_pypi import Environment
+from python_inspector.utils_pypi import PypiSimpleRepository
 
 
 class Candidate(NamedTuple):
@@ -42,7 +49,7 @@ class Candidate(NamedTuple):
     extras: str
 
 
-def get_response(url):
+def get_response(url: str):
     """
     Return a response for the given url.
     """
@@ -52,7 +59,7 @@ def get_response(url):
     return None
 
 
-def get_requirements_from_distribution(handler, location):
+def get_requirements_from_distribution(handler: BasePypiHandler, location: str):
     """
     Return a list of requirements from a distribution.
     """
@@ -63,7 +70,7 @@ def get_requirements_from_distribution(handler, location):
     return list(get_requirements_from_dependencies(dependencies=deps[0].dependencies))
 
 
-def is_requirements_file_in_setup_files(setup_files):
+def is_requirements_file_in_setup_files(setup_files: List[str]):
     """
     Return True if the given ``requirements.txt`` is in the given ``setup_files``.
     """
@@ -76,7 +83,12 @@ def is_requirements_file_in_setup_files(setup_files):
     return False
 
 
-def is_valid_version(parsed_version, requirements, identifier, bad_versions):
+def is_valid_version(
+    parsed_version: Union[LegacyVersion, Version],
+    requirements: Dict,
+    identifier: str,
+    bad_versions: List[Version],
+):
     """
     Return True if the parsed_version is valid for the given identifier.
     """
@@ -99,7 +111,9 @@ def get_python_version_from_env_tag(python_version: str):
     return python_version
 
 
-def fetch_and_extract_sdist(repos, candidate, python_version):
+def fetch_and_extract_sdist(
+    repos: List[PypiSimpleRepository], candidate: Candidate, python_version: str
+):
     """
     Fetch and extract the source distribution (sdist) for the ``candidate`` Candidate
     from the `repos` list of PyPiRepository
@@ -139,7 +153,7 @@ def fetch_and_extract_sdist(repos, candidate, python_version):
     return os.path.join(utils_pypi.CACHE_THIRDPARTY_DIR, "extracted_sdists", sdist_file, sdist_file)
 
 
-def get_requirements_from_dependencies(dependencies):
+def get_requirements_from_dependencies(dependencies: List[DependentPackage]):
     """
     Generate parsed requirements for the given ``dependencies``.
     """
@@ -153,10 +167,10 @@ def get_requirements_from_dependencies(dependencies):
         # skip the requirement starting with -- like
         # --editable, --requirement
         if not dep.extracted_requirement.startswith("-"):
-            yield packaging.requirements.Requirement(str(dep.extracted_requirement))
+            yield Requirement(str(dep.extracted_requirement))
 
 
-def remove_extras(identifier):
+def remove_extras(identifier: str):
     """
     Return the identifier without extras.
     >>> assert remove_extras("foo[bar]") == "foo"
@@ -173,7 +187,7 @@ def __init__(self, environment=None, repos=tuple()):
         self.dependencies_by_purl = {}
         self.wheel_or_sdist_by_package = {}
 
-    def identify(self, requirement_or_candidate):
+    def identify(self, requirement_or_candidate: Union[Candidate, Requirement]):
         """Given a requirement, return an identifier for it. Overridden."""
         name = packaging.utils.canonicalize_name(requirement_or_candidate.name)
         if requirement_or_candidate.extras:
@@ -194,7 +208,9 @@ def get_preference(
         transitive = all(p is not None for _, p in information[identifier])
         return transitive, identifier
 
-    def get_versions_for_package(self, name, repo=None):
+    def get_versions_for_package(
+        self, name: str, repo: Union[List[PypiSimpleRepository], None] = None
+    ):
         """
         Return a list of versions for a package.
         """
@@ -203,13 +219,13 @@ def get_versions_for_package(self, name, repo=None):
         else:
             return self.get_versions_for_package_from_pypi_json_api(name)
 
-    def get_versions_for_package_from_repo(self, name, repo):
+    def get_versions_for_package_from_repo(self, name: str, repo: PypiSimpleRepository):
         """
         Return a list of versions for a package name from a repo
         """
         versions = []
         for version, package in repo.get_package_versions(name).items():
-            python_version = packaging.version.parse(
+            python_version = parse_version(
                 get_python_version_from_env_tag(python_version=self.environment.python_version)
             )
             wheels = list(package.get_supported_wheels(environment=self.environment))
@@ -225,7 +241,7 @@ def get_versions_for_package_from_repo(self, name, repo):
                     versions.append(version)
         return versions
 
-    def get_versions_for_package_from_pypi_json_api(self, name):
+    def get_versions_for_package_from_pypi_json_api(self, name: str):
         """
         Return a list of versions for a package name from the PyPI.org JSON API
         """
@@ -239,7 +255,7 @@ def get_versions_for_package_from_pypi_json_api(self, name):
         versions = self.versions_by_package[name]
         return versions
 
-    def get_requirements_for_package(self, purl, candidate):
+    def get_requirements_for_package(self, purl: PackageURL, candidate: Candidate):
         """
         Yield requirements for a package.
         """
@@ -248,11 +264,11 @@ def get_requirements_for_package(self, purl, candidate):
         else:
             return self.get_requirements_for_package_from_pypi_json_api(purl)
 
-    def get_requirements_for_package_from_pypi_simple(self, candidate):
+    def get_requirements_for_package_from_pypi_simple(self, candidate: Candidate):
         """
         Return requirements for a package from the simple repositories.
         """
-        python_version = packaging.version.parse(
+        python_version = parse_version(
             get_python_version_from_env_tag(python_version=self.environment.python_version)
         )
 
@@ -321,7 +337,7 @@ def get_requirements_for_package_from_pypi_simple(self, candidate):
                     if deps:
                         yield from deps
 
-    def get_requirements_for_package_from_pypi_json_api(self, purl):
+    def get_requirements_for_package_from_pypi_json_api(self, purl: PackageURL):
         """
         Return requirements for a package from the PyPI.org JSON API
         """
@@ -335,14 +351,22 @@ def get_requirements_for_package_from_pypi_json_api(self, purl):
             requires_dist = info.get("requires_dist") or []
             self.dependencies_by_purl[str(purl)] = requires_dist
         for dependency in self.dependencies_by_purl[str(purl)]:
-            yield packaging.requirements.Requirement(dependency)
+            yield Requirement(dependency)
 
-    def get_candidates(self, all_versions, requirements, identifier, bad_versions, name, extras):
+    def get_candidates(
+        self,
+        all_versions: List[str],
+        requirements: List[Requirement],
+        identifier: str,
+        bad_versions: List[str],
+        name: str,
+        extras: Dict,
+    ):
         """
         Generate candidates for the given identifier. Overridden.
         """
         for version in all_versions:
-            parsed_version = packaging.version.parse(version)
+            parsed_version = parse_version(version)
             if not is_valid_version(
                 parsed_version=parsed_version,
                 requirements=requirements,
@@ -352,7 +376,12 @@ def get_candidates(self, all_versions, requirements, identifier, bad_versions, n
                 continue
             yield Candidate(name=name, version=parsed_version, extras=extras)
 
-    def _iter_matches(self, identifier, requirements, incompatibilities):
+    def _iter_matches(
+        self,
+        identifier: str,
+        requirements: List[Requirement],
+        incompatibilities: Dict,
+    ):
         """
         Yield candidates for the given identifier, requirements and incompatibilities
         """
@@ -371,7 +400,12 @@ def _iter_matches(self, identifier, requirements, incompatibilities):
                     all_versions, requirements, identifier, bad_versions, name, extras
                 )
 
-    def find_matches(self, identifier, requirements, incompatibilities):
+    def find_matches(
+        self,
+        identifier: str,
+        requirements: List[Requirement],
+        incompatibilities: Dict,
+    ):
         """Find all possible candidates that satisfy given constraints. Overridden."""
         candidates = sorted(
             self._iter_matches(identifier, requirements, incompatibilities),
@@ -380,19 +414,19 @@ def find_matches(self, identifier, requirements, incompatibilities):
         )
         return candidates
 
-    def is_satisfied_by(self, requirement, candidate):
+    def is_satisfied_by(self, requirement: Requirement, candidate: Candidate):
         """Whether the given requirement can be satisfied by a candidate. Overridden."""
         return candidate.version in requirement.specifier
 
-    def _iter_dependencies(self, candidate):
+    def _iter_dependencies(self, candidate: Candidate):
         """
         Yield dependencies for the given candidate.
         """
         name = packaging.utils.canonicalize_name(candidate.name)
         # TODO: handle extras https://github.com/nexB/python-inspector/issues/10
         if candidate.extras:
             r = f"{name}=={candidate.version}"
-            yield packaging.requirements.Requirement(r)
+            yield Requirement(r)
 
         purl = PackageURL(
             type="pypi",
@@ -416,12 +450,17 @@ def _iter_dependencies(self, candidate):
                 ):
                     yield r
 
-    def get_dependencies(self, candidate):
+    def get_dependencies(self, candidate: Candidate):
         """Get dependencies of a candidate. Overridden."""
         return list(self._iter_dependencies(candidate))
 
 
-def get_wheel_download_urls(purl, repos, environment, python_version):
+def get_wheel_download_urls(
+    purl: PackageURL,
+    repos: List[PypiSimpleRepository],
+    environment: Environment,
+    python_version: str,
+):
     """
     Return a list of download urls for the given purl.
     """
@@ -436,7 +475,9 @@ def get_wheel_download_urls(purl, repos, environment, python_version):
             yield wheel.download_url
 
 
-def get_sdist_download_url(purl, repos, python_version):
+def get_sdist_download_url(
+    purl: PackageURL, repos: List[PypiSimpleRepository], python_version: str
+):
     """
     Return a list of download urls for the given purl.
     """
@@ -479,7 +520,9 @@ def dfs(mapping, graph, src):
     )
 
 
-def format_resolution(results, environment, repos, as_tree=False):
+def format_resolution(
+    results, environment: Environment, repos: List[PypiSimpleRepository], as_tree=False
+):
     """
     Return a formatted resolution either as a tree or parent/children.
     """
@@ -540,8 +583,8 @@ def format_resolution(results, environment, repos, as_tree=False):
 
 def get_resolved_dependencies(
     requirements: List[Requirement],
-    environment: utils_pypi.Environment = None,
-    repos: Sequence[utils_pypi.PypiSimpleRepository] = tuple(),
+    environment: Environment = None,
+    repos: Sequence[PypiSimpleRepository] = tuple(),
     as_tree: bool = False,
     max_rounds: int = 200000,
 ):