Merge remote-tracking branch 'origin/master' into rm-imp-again

Author: adamtheturtle

.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+- package-ecosystem: pip
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10
+- package-ecosystem: "github-actions"
+  directory: "/"
+  schedule:
+    interval: daily

.github/workflows/ci.yml

@@ -27,13 +27,13 @@ jobs:
         python-version: ["3.8", "3.9", "3.10", "3.11"]
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: "Set up Python"
         uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python-version }}
 
-      - uses: actions/cache@v2
+      - uses: actions/cache@v3
         with:
           path: ~/.cache/pip
           # This is like the example but we use ``*requirements.txt`` rather
@@ -55,9 +55,8 @@ jobs:
 
       - name: "Lint"
         run: |
-          flake8 *.py pip_check_reqs tests
           mypy .
-          isort --check-only .
+          ruff .
           black --check .
           pylint pip_check_reqs tests
           pip-extra-reqs pip_check_reqs

pip_check_reqs/common.py

@@ -1,5 +1,7 @@
 """Common functions."""
 
+from __future__ import annotations
+
 import ast
 import fnmatch
 # import imp
@@ -12,14 +14,8 @@
 from pathlib import Path
 from typing import (
     Callable,
-    Dict,
     Generator,
     Iterable,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Union,
 )
 
 from packaging.markers import Marker
@@ -39,7 +35,7 @@ class FoundModule:
 
     modname: str
     filename: str
-    locations: List[Tuple[str, int]] = field(default_factory=list)
+    locations: list[tuple[str, int]] = field(default_factory=list)
 
     def __post_init__(self) -> None:
         self.filename = os.path.realpath(self.filename)
@@ -49,22 +45,22 @@ class _ImportVisitor(ast.NodeVisitor):
     def __init__(self, ignore_modules_function: Callable[[str], bool]) -> None:
         super().__init__()
         self._ignore_modules_function = ignore_modules_function
-        self._modules: Dict[str, FoundModule] = {}
-        self._location: Optional[str] = None
+        self._modules: dict[str, FoundModule] = {}
+        self._location: str | None = None
 
     def set_location(self, location: str) -> None:
         self._location = location
 
     # Ignore the name error as we are overriding the method.
-    def visit_Import(  # pylint: disable=invalid-name
+    def visit_Import(  # noqa: N802, pylint: disable=invalid-name
         self,
         node: ast.Import,
     ) -> None:
         for alias in node.names:
             self._add_module(alias.name, node.lineno)
 
     # Ignore the name error as we are overriding the method.
-    def visit_ImportFrom(  # pylint: disable=invalid-name
+    def visit_ImportFrom(  # noqa: N802, pylint: disable=invalid-name
         self,
         node: ast.ImportFrom,
     ) -> None:
@@ -104,7 +100,7 @@ def _add_module(self, modname: str, lineno: int) -> None:
                 break
 
             # ... though it might not be a file, so not interesting to us
-            if not os.path.isdir(modpath):
+            if not Path(modpath).is_dir():
                 break
 
             path = [modpath]
@@ -120,18 +116,18 @@ def _add_module(self, modname: str, lineno: int) -> None:
         assert isinstance(self._location, str)
         self._modules[modname].locations.append((self._location, lineno))
 
-    def finalise(self) -> Dict[str, FoundModule]:
-        result = self._modules
-        return result
+    def finalise(self) -> dict[str, FoundModule]:
+        return self._modules
 
 
 def pyfiles(root: Path) -> Generator[Path, None, None]:
     if root.is_file():
         if root.suffix == ".py":
             yield root.absolute()
         else:
-            raise ValueError(f"{root} is not a python file or directory")
-    elif root.is_dir():
+            msg = f"{root} is not a python file or directory"
+            raise ValueError(msg)
+    else:
         for item in root.rglob("*.py"):
             yield item.absolute()
 
@@ -140,31 +136,33 @@ def find_imported_modules(
     paths: Iterable[Path],
     ignore_files_function: Callable[[str], bool],
     ignore_modules_function: Callable[[str], bool],
-) -> Dict[str, FoundModule]:
+) -> dict[str, FoundModule]:
     vis = _ImportVisitor(ignore_modules_function=ignore_modules_function)
     for path in paths:
         for filename in pyfiles(path):
             if ignore_files_function(str(filename)):
                 log.info("ignoring: %s", os.path.relpath(filename))
                 continue
             log.debug("scanning: %s", os.path.relpath(filename))
-            with open(filename, encoding="utf-8") as file_obj:
-                content = file_obj.read()
+            content = filename.read_text(encoding="utf-8")
             vis.set_location(str(filename))
             vis.visit(ast.parse(content, str(filename)))
     return vis.finalise()
 
 
 def find_required_modules(
+    *,
     ignore_requirements_function: Callable[
-        [Union[str, ParsedRequirement]], bool
+        [str | ParsedRequirement],
+        bool,
     ],
     skip_incompatible: bool,
     requirements_filename: Path,
-) -> Set[NormalizedName]:
+) -> set[NormalizedName]:
     explicit = set()
     for requirement in parse_requirements(
-        str(requirements_filename), session=PipSession()
+        str(requirements_filename),
+        session=PipSession(),
     ):
         requirement_name = install_req_from_line(
             requirement.requirement,
@@ -203,22 +201,23 @@ def has_compatible_markers(full_requirement: str) -> bool:
 
 
 def is_package_file(path: str) -> str:
-    """Determines whether the path points to a Python package sentinel
-    file - the __init__.py or its compiled variants.
+    """Determine whether the path points to a Python package sentinel file.
+
+    A sentinel file is the __init__.py or its compiled variants.
     """
     search_result = re.search(r"(.+)/__init__\.py[co]?$", path)
     if search_result is not None:
         return search_result.group(1)
     return ""
 
 
-def ignorer(ignore_cfg: List[str]) -> Callable[..., bool]:
+def ignorer(ignore_cfg: list[str]) -> Callable[..., bool]:
     if not ignore_cfg:
-        return lambda candidate: False
+        return lambda _: False
 
     def ignorer_function(
-        candidate: Union[str, ParsedRequirement],
-        ignore_cfg: List[str] = ignore_cfg,
+        candidate: str | ParsedRequirement,
+        ignore_cfg: list[str] = ignore_cfg,
     ) -> bool:
         for ignore in ignore_cfg:
             if isinstance(candidate, str):

pip_check_reqs/find_extra_reqs.py

@@ -1,35 +1,41 @@
 """Find extra requirements."""
 
+from __future__ import annotations
+
 import argparse
 import collections
 import importlib.metadata
 import logging
 import os
 import sys
 from pathlib import Path
-from typing import Callable, Iterable, List, Optional, Union
+from typing import TYPE_CHECKING, Callable, Iterable
 from unittest import mock
 
 from packaging.utils import canonicalize_name
 from pip._internal.commands.show import search_packages_info
-from pip._internal.req.req_file import ParsedRequirement
 
 from pip_check_reqs import common
 from pip_check_reqs.common import version_info
 
+if TYPE_CHECKING:
+    from pip._internal.req.req_file import ParsedRequirement
+
 log = logging.getLogger(__name__)
 
 
 def find_extra_reqs(
+    *,
     requirements_filename: Path,
     paths: Iterable[Path],
     ignore_files_function: Callable[[str], bool],
     ignore_modules_function: Callable[[str], bool],
     ignore_requirements_function: Callable[
-        [Union[str, ParsedRequirement]], bool
+        [str | ParsedRequirement],
+        bool,
     ],
     skip_incompatible: bool,
-) -> List[str]:
+) -> list[str]:
     # 1. find files used by imports in the code (as best we can without
     #    executing)
     used_modules = common.find_imported_modules(
@@ -55,7 +61,7 @@ def find_extra_reqs(
         package_location = package.location
         package_files = []
         for item in package.files or []:
-            here = Path(".").resolve()
+            here = Path().resolve()
             item_location_rel = Path(package_location) / item
             item_location = item_location_rel.resolve()
             try:
@@ -68,11 +74,13 @@ def find_extra_reqs(
             package_files.append(str(relative_item_location))
 
         log.debug(
-            "installed package: %s (at %s)", package_name, package_location
+            "installed package: %s (at %s)",
+            package_name,
+            package_location,
         )
         for package_file in package_files:
             path = os.path.realpath(
-                os.path.join(package_location, package_file),
+                Path(package_location) / package_file,
             )
             installed_files[path] = package_name
             package_path = common.is_package_file(path)
@@ -112,8 +120,8 @@ def find_extra_reqs(
     return [name for name in explicit if name not in used]
 
 
-def main(arguments: Optional[List[str]] = None) -> None:
-    """Main entry point."""
+def main(arguments: list[str] | None = None) -> None:
+    """pip-extra-reqs entry point."""
     usage = "usage: %prog [options] files or directories"
     parser = argparse.ArgumentParser(usage)
     parser.add_argument("paths", type=Path, nargs="*")
@@ -156,7 +164,7 @@ def main(arguments: Optional[List[str]] = None) -> None:
         dest="skip_incompatible",
         action="store_true",
         default=False,
-        help="skip requirements that have incompatible " "environment markers",
+        help="skip requirements that have incompatible environment markers",
     )
     parser.add_argument(
         "-v",
@@ -186,7 +194,7 @@ def main(arguments: Optional[List[str]] = None) -> None:
     parse_result = parser.parse_args(arguments)
 
     if parse_result.version:
-        print(version_info())
+        sys.stdout.write(version_info() + "\n")
         sys.exit(0)
 
     if not parse_result.paths:

pip_check_reqs/find_missing_reqs.py

@@ -1,13 +1,15 @@
 """Find missing requirements."""
 
+from __future__ import annotations
+
 import argparse
 import collections
 import importlib.metadata
 import logging
 import os
 import sys
 from pathlib import Path
-from typing import Callable, Iterable, List, Optional, Tuple
+from typing import Callable, Iterable
 from unittest import mock
 
 from packaging.utils import NormalizedName, canonicalize_name
@@ -27,7 +29,7 @@ def find_missing_reqs(
     paths: Iterable[Path],
     ignore_files_function: Callable[[str], bool],
     ignore_modules_function: Callable[[str], bool],
-) -> List[Tuple[NormalizedName, List[FoundModule]]]:
+) -> list[tuple[NormalizedName, list[FoundModule]]]:
     # 1. find files used by imports in the code (as best we can without
     #    executing)
     used_modules = common.find_imported_modules(
@@ -53,7 +55,7 @@ def find_missing_reqs(
         package_location = package.location
         package_files = []
         for item in package.files or []:
-            here = Path(".").resolve()
+            here = Path().resolve()
             item_location_rel = Path(package_location) / item
             item_location = item_location_rel.resolve()
             try:
@@ -66,11 +68,13 @@ def find_missing_reqs(
             package_files.append(str(relative_item_location))
 
         log.debug(
-            "installed package: %s (at %s)", package_name, package_location
+            "installed package: %s (at %s)",
+            package_name,
+            package_location,
         )
         for package_file in package_files:
             path = os.path.realpath(
-                os.path.join(package_location, package_file),
+                str(Path(package_location) / package_file),
             )
             installed_files[path] = package_name
             package_path = common.is_package_file(path)
@@ -113,11 +117,10 @@ def find_missing_reqs(
         log.debug("found requirement: %s", requirement_name)
         explicit.add(canonicalize_name(requirement_name))
 
-    result = [(name, used[name]) for name in used if name not in explicit]
-    return result
+    return [(name, used[name]) for name in used if name not in explicit]
 
 
-def main(arguments: Optional[List[str]] = None) -> None:
+def main(arguments: list[str] | None = None) -> None:
     usage = "usage: %prog [options] files or directories"
     parser = argparse.ArgumentParser(usage)
     parser.add_argument("paths", type=Path, nargs="*")
@@ -174,7 +177,7 @@ def main(arguments: Optional[List[str]] = None) -> None:
     parse_result = parser.parse_args(arguments)
 
     if parse_result.version:
-        print(version_info())
+        sys.stdout.write(version_info() + "\n")
         sys.exit(0)
 
     if not parse_result.paths: