Merge branch 'fast' of github.com:oraluben/auditwheel into fast

Author: oraluben

pyproject.toml

@@ -15,8 +15,9 @@ enable_error_code = ["ignore-without-code", "redundant-expr", "truthy-bool"]
 extra_checks = true
 strict = false
 strict_equality = true
-warn_unused_configs = true
+warn_redundant_casts = true
 warn_unreachable = false
+warn_unused_configs = true
 warn_unused_ignores = true
 
 [[tool.mypy.overrides]]

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,14 +150,14 @@ def get_undefined_symbols(path: str) -> set[str]:
 
 
 def filter_undefined_symbols(
-    path: str, symbols: dict[str, list[str]]
+    path: Path, symbols: dict[str, frozenset[str]]
 ) -> dict[str, list[str]]:
     if not symbols:
         return {}
     undef_symbols = set("*") | get_undefined_symbols(path)
     result = {}
     for lib, sym_list in symbols.items():
-        intersection = set(sym_list) & undef_symbols
+        intersection = sym_list & undef_symbols
         if intersection:
             result[lib] = sorted(intersection)
     return result

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,19 +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):
-        return dataclasses.asdict(value)
-    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),