chore: use Path instead of str

Author: mayeut

src/auditwheel/condatools.py

@@ -4,27 +4,27 @@
 
 from __future__ import annotations
 
-import os
+from pathlib import Path
 
 from .tmpdirs import InTemporaryDirectory
 from .tools import tarbz2todir
 
 
 class InCondaPkg(InTemporaryDirectory):
-    def __init__(self, in_conda_pkg: str) -> None:
+    def __init__(self, in_conda_pkg: Path) -> None:
         """Initialize in-conda-package context manager"""
-        self.in_conda_pkg = os.path.abspath(in_conda_pkg)
+        self.in_conda_pkg = in_conda_pkg.absolute()
         super().__init__()
 
-    def __enter__(self) -> str:
+    def __enter__(self) -> Path:
         tarbz2todir(self.in_conda_pkg, self.name)
         return super().__enter__()
 
 
 class InCondaPkgCtx(InCondaPkg):
-    def __init__(self, in_conda_pkg: str) -> None:
+    def __init__(self, in_conda_pkg: Path) -> None:
         super().__init__(in_conda_pkg)
-        self.path: str | None = None
+        self.path: Path | None = None
 
     def __enter__(self):  # type: ignore[no-untyped-def]
         self.path = super().__enter__()
@@ -34,6 +34,6 @@ def iter_files(self) -> list[str]:
         if self.path is None:
             msg = "This function should be called from context manager"
             raise ValueError(msg)
-        files = os.path.join(self.path, "info", "files")
+        files = self.path / "info" / "files"
         with open(files) as f:
             return [line.strip() for line in f.readlines()]

src/auditwheel/elfutils.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from collections.abc import Iterable, Iterator
-from os.path import basename
 from pathlib import Path
 
 from elftools.common.exceptions import ELFError
@@ -10,7 +9,7 @@
 from .lddtree import parse_ld_paths
 
 
-def elf_read_dt_needed(fn: str) -> list[str]:
+def elf_read_dt_needed(fn: Path) -> list[str]:
     needed = []
     with open(fn, "rb") as f:
         elf = ELFFile(f)
@@ -26,13 +25,13 @@ def elf_read_dt_needed(fn: str) -> list[str]:
     return needed
 
 
-def elf_file_filter(paths: Iterable[str]) -> Iterator[tuple[str, ELFFile]]:
+def elf_file_filter(paths: Iterable[Path]) -> Iterator[tuple[Path, ELFFile]]:
     """Filter through an iterator of filenames and load up only ELF
     files
     """
 
     for path in paths:
-        if path.endswith(".py"):
+        if path.name.endswith(".py"):
             continue
         else:
             try:
@@ -86,8 +85,8 @@ def elf_references_PyFPE_jbuf(elf: ELFFile) -> bool:
     return False
 
 
-def elf_is_python_extension(fn: str, elf: ELFFile) -> tuple[bool, int | None]:
-    modname = basename(fn).split(".", 1)[0]
+def elf_is_python_extension(fn: Path, elf: ELFFile) -> tuple[bool, int | None]:
+    modname = fn.name.split(".", 1)[0]
     module_init_f = {
         "init" + modname: 2,
         "PyInit_" + modname: 3,
@@ -109,7 +108,7 @@ def elf_is_python_extension(fn: str, elf: ELFFile) -> tuple[bool, int | None]:
     return False, None
 
 
-def elf_read_rpaths(fn: str) -> dict[str, list[str]]:
+def elf_read_rpaths(fn: Path) -> dict[str, list[str]]:
     result: dict[str, list[str]] = {"rpaths": [], "runpaths": []}
 
     with open(fn, "rb") as f:
@@ -120,9 +119,9 @@ def elf_read_rpaths(fn: str) -> dict[str, list[str]]:
 
         for t in section.iter_tags():
             if t.entry.d_tag == "DT_RPATH":
-                result["rpaths"] = parse_ld_paths(t.rpath, root="/", path=fn)
+                result["rpaths"] = parse_ld_paths(t.rpath, root="/", path=str(fn))
             elif t.entry.d_tag == "DT_RUNPATH":
-                result["runpaths"] = parse_ld_paths(t.runpath, root="/", path=fn)
+                result["runpaths"] = parse_ld_paths(t.runpath, root="/", path=str(fn))
 
     return result
 
@@ -137,7 +136,7 @@ def is_subdir(path: str | Path | None, directory: str | Path) -> bool:
     return directory in path.parents
 
 
-def get_undefined_symbols(path: str) -> set[str]:
+def get_undefined_symbols(path: Path) -> set[str]:
     undef_symbols = set()
     with open(path, "rb") as f:
         elf = ELFFile(f)
@@ -151,7 +150,7 @@ def get_undefined_symbols(path: str) -> set[str]:
 
 
 def filter_undefined_symbols(
-    path: str, symbols: dict[str, frozenset[str]]
+    path: Path, symbols: dict[str, frozenset[str]]
 ) -> dict[str, list[str]]:
     if not symbols:
         return {}

src/auditwheel/genericpkgctx.py

@@ -1,18 +1,20 @@
 from __future__ import annotations
 
+from pathlib import Path
+
 from .condatools import InCondaPkgCtx
 from .wheeltools import InWheelCtx
 
 
 def InGenericPkgCtx(
-    in_path: str, out_path: str | None = None
+    in_path: Path, out_path: Path | None = None
 ) -> InWheelCtx | InCondaPkgCtx:
     """Factory that returns a InWheelCtx or InCondaPkgCtx
     context manager depending on the file extension
     """
-    if in_path.endswith(".whl"):
+    if in_path.name.endswith(".whl"):
         return InWheelCtx(in_path, out_path)
-    if in_path.endswith(".tar.bz2"):
+    if in_path.name.endswith(".tar.bz2"):
         if out_path is not None:
             raise NotImplementedError()
         return InCondaPkgCtx(in_path)

src/auditwheel/json.py

@@ -3,21 +3,29 @@
 import dataclasses
 import json
 from enum import Enum
+from pathlib import PurePath
 from typing import Any
 
 
-def _encode_value(value: Any) -> Any:
-    if dataclasses.is_dataclass(value) and not isinstance(value, type):
-        as_dict = dataclasses.asdict(value)
-        as_dict.pop("policy", None)  # don't dump full policy in logs
-        return as_dict
-    if isinstance(value, frozenset):
-        return sorted(value)
-    if isinstance(value, Enum):
-        return repr(value)
-    msg = f"object of type {value.__class__.__name__!r} can't be encoded to JSON"
-    raise TypeError(msg)
+class _CustomEncoder(json.JSONEncoder):
+    def default(self, value: Any) -> Any:
+        if dataclasses.is_dataclass(value) and not isinstance(value, type):
+            as_dict = dataclasses.asdict(value)
+            as_dict.pop("policy", None)  # don't dump full policy in logs
+            return as_dict
+        if isinstance(value, frozenset):
+            return sorted(value)
+        if isinstance(value, Enum):
+            return repr(value)
+        if isinstance(value, PurePath):
+            return str(value)
+        return super().default(value)
+
+    def encode(self, o: Any) -> str:
+        if isinstance(o, dict):
+            o = {str(k): v for k, v in o.items()}
+        return super().encode(o)
 
 
 def dumps(obj: Any) -> str:
-    return json.dumps(obj, indent=4, default=_encode_value)
+    return json.dumps(obj, indent=4, cls=_CustomEncoder)

src/auditwheel/lddtree.py

@@ -72,7 +72,7 @@ def extended_architecture(self) -> Architecture | None:
 class DynamicLibrary:
     soname: str
     path: str | None
-    realpath: str | None
+    realpath: Path | None
     platform: Platform | None = None
     needed: frozenset[str] = frozenset()
 
@@ -81,7 +81,7 @@ class DynamicLibrary:
 class DynamicExecutable:
     interpreter: str | None
     path: str
-    realpath: str
+    realpath: Path
     platform: Platform
     needed: frozenset[str]
     rpath: tuple[str, ...]
@@ -354,7 +354,7 @@ def load_ld_paths(root: str = "/", prefix: str = "") -> dict[str, list[str]]:
 
 def find_lib(
     platform: Platform, lib: str, ldpaths: list[str], root: str = "/"
-) -> tuple[str | None, str | None]:
+) -> tuple[Path | None, str | None]:
     """Try to locate a ``lib`` that is compatible to ``elf`` in the given
     ``ldpaths``
 
@@ -376,9 +376,9 @@ def find_lib(
 
     for ldpath in ldpaths:
         path = os.path.join(ldpath, lib)
-        target = readlink(path, root, prefixed=True)
+        target = Path(readlink(path, root, prefixed=True))
 
-        if os.path.exists(target):
+        if target.exists():
             with open(target, "rb") as f:
                 libelf = ELFFile(f)
                 if platform.is_compatible(_get_platform(libelf)):
@@ -388,7 +388,7 @@ def find_lib(
 
 
 def ldd(
-    path: str,
+    path: Path,
     root: str = "/",
     prefix: str = "",
     ldpaths: dict[str, list[str]] | None = None,
@@ -481,9 +481,9 @@ def ldd(
 
             for t in segment.iter_tags():
                 if t.entry.d_tag == "DT_RPATH":
-                    rpaths = parse_ld_paths(t.rpath, path=path, root=root)
+                    rpaths = parse_ld_paths(t.rpath, path=str(path), root=root)
                 elif t.entry.d_tag == "DT_RUNPATH":
-                    runpaths = parse_ld_paths(t.runpath, path=path, root=root)
+                    runpaths = parse_ld_paths(t.runpath, path=str(path), root=root)
                 elif t.entry.d_tag == "DT_NEEDED":
                     needed.add(t.needed)
             if runpaths:
@@ -525,7 +525,7 @@ def ldd(
             _excluded_libs.add(soname)
             continue
         realpath, fullpath = find_lib(platform, soname, all_ldpaths, root)
-        if realpath is not None and any(fnmatch(realpath, e) for e in exclude):
+        if realpath is not None and any(fnmatch(str(realpath), e) for e in exclude):
             log.info("Excluding %s", realpath)
             _excluded_libs.add(soname)
             continue
@@ -544,12 +544,15 @@ def ldd(
     if interpreter is not None:
         soname = os.path.basename(interpreter)
         _all_libs[soname] = DynamicLibrary(
-            soname, interpreter, readlink(interpreter, root, prefixed=True), platform
+            soname,
+            interpreter,
+            Path(readlink(interpreter, root, prefixed=True)),
+            platform,
         )
 
     return DynamicExecutable(
         interpreter,
-        path if display is None else display,
+        str(path) if display is None else display,
         path,
         platform,
         frozenset(needed - _excluded_libs),

src/auditwheel/main_repair.py

@@ -2,7 +2,7 @@
 
 import argparse
 import logging
-from os.path import abspath, basename, exists, isfile
+from pathlib import Path
 
 from auditwheel.patcher import Patchelf
 
@@ -39,7 +39,7 @@ def configure_parser(sub_parsers) -> None:  # type: ignore[no-untyped-def]
         epilog=epilog,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
-    parser.add_argument("WHEEL_FILE", help="Path to wheel file.", nargs="+")
+    parser.add_argument("WHEEL_FILE", type=Path, help="Path to wheel file.", nargs="+")
     parser.add_argument(
         "--plat",
         action=EnvironmentDefault,
@@ -62,7 +62,7 @@ def configure_parser(sub_parsers) -> None:  # type: ignore[no-untyped-def]
         "-w",
         "--wheel-dir",
         dest="WHEEL_DIR",
-        type=abspath,
+        type=Path,
         help=('Directory to store delocated wheels (default: "wheelhouse/")'),
         default="wheelhouse/",
     )
@@ -112,22 +112,22 @@ def configure_parser(sub_parsers) -> None:  # type: ignore[no-untyped-def]
 
 
 def execute(args: argparse.Namespace, parser: argparse.ArgumentParser) -> int:
-    import os
-
     from .repair import repair_wheel
     from .wheel_abi import NonPlatformWheel, analyze_wheel_abi
 
-    exclude = frozenset(args.EXCLUDE)
+    exclude: frozenset[str] = frozenset(args.EXCLUDE)
+    wheel_dir: Path = args.WHEEL_DIR.absolute()
+    wheel_files: list[Path] = args.WHEEL_FILE
     wheel_policy = WheelPolicies()
 
-    for wheel_file in args.WHEEL_FILE:
-        if not isfile(wheel_file):
+    for wheel_file in wheel_files:
+        if not wheel_file.is_file():
             parser.error(f"cannot access {wheel_file}. No such file")
 
-        logger.info("Repairing %s", basename(wheel_file))
+        logger.info("Repairing %s", wheel_file.name)
 
-        if not exists(args.WHEEL_DIR):
-            os.makedirs(args.WHEEL_DIR)
+        if not wheel_dir.exists():
+            wheel_dir.mkdir(parents=True)
 
         try:
             wheel_abi = analyze_wheel_abi(
@@ -192,7 +192,7 @@ def execute(args: argparse.Namespace, parser: argparse.ArgumentParser) -> int:
             wheel_file,
             abis=abis,
             lib_sdir=args.LIB_SDIR,
-            out_dir=args.WHEEL_DIR,
+            out_dir=wheel_dir,
             update_tags=args.UPDATE_TAGS,
             patcher=patcher,
             exclude=exclude,

src/auditwheel/main_show.py

@@ -2,6 +2,7 @@
 
 import argparse
 import logging
+from pathlib import Path
 
 from auditwheel.policy import WheelPolicies
 
@@ -11,7 +12,7 @@
 def configure_parser(sub_parsers) -> None:  # type: ignore[no-untyped-def]
     help = "Audit a wheel for external shared library dependencies."
     p = sub_parsers.add_parser("show", help=help, description=help)
-    p.add_argument("WHEEL_FILE", help="Path to wheel file.")
+    p.add_argument("WHEEL_FILE", type=Path, help="Path to wheel file.")
     p.add_argument(
         "--disable-isa-ext-check",
         dest="DISABLE_ISA_EXT_CHECK",
@@ -30,21 +31,19 @@ def printp(text: str) -> None:
 
 
 def execute(args: argparse.Namespace, parser: argparse.ArgumentParser) -> int:
-    from os.path import basename, isfile
-
     from . import json
     from .wheel_abi import NonPlatformWheel, analyze_wheel_abi
 
     wheel_policy = WheelPolicies()
+    wheel_file: Path = args.WHEEL_FILE
+    fn = wheel_file.name
 
-    fn = basename(args.WHEEL_FILE)
-
-    if not isfile(args.WHEEL_FILE):
-        parser.error(f"cannot access {args.WHEEL_FILE}. No such file")
+    if not wheel_file.is_file():
+        parser.error(f"cannot access {wheel_file}. No such file")
 
     try:
         winfo = analyze_wheel_abi(
-            wheel_policy, args.WHEEL_FILE, frozenset(), args.DISABLE_ISA_EXT_CHECK
+            wheel_policy, wheel_file, frozenset(), args.DISABLE_ISA_EXT_CHECK
         )
     except NonPlatformWheel as e:
         logger.info(e.message)