[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

src/auditwheel/elfutils.py

@@ -5,11 +5,11 @@
 from typing import Iterator
 
 from elftools.common.exceptions import ELFError
-from elftools.elf.elffile import ELFFile
 from elftools.elf.dynamic import DynamicSegment
+from elftools.elf.elffile import ELFFile
 
-from .libc import Libc
 from .lddtree import parse_ld_paths
+from .libc import Libc
 
 
 def elf_read_dt_needed(fn: str) -> list[str]:
@@ -164,6 +164,7 @@ def filter_undefined_symbols(
             result[lib] = sorted(intersection)
     return result
 
+
 def elf_get_platform_info(path: str) -> tuple[Libc | None, str | None]:
     with open(path, "rb") as f:
         try:
@@ -179,19 +180,19 @@ def elf_get_platform_info(path: str) -> tuple[Libc | None, str | None]:
             "ARM": "armv7l",
             "RISC-V": "riscv64",
         }[elf.get_machine_arch()]
-        if arch == 'ppc64' and elf.header.e_ident.EI_DATA == 'ELFDATA2LSB':
-            arch = 'ppc64le'
+        if arch == "ppc64" and elf.header.e_ident.EI_DATA == "ELFDATA2LSB":
+            arch = "ppc64le"
 
         libc = None
         for seg in elf.iter_segments():
             if not isinstance(seg, DynamicSegment):
                 continue
             for tag in seg.iter_tags():
                 if tag.entry.d_tag == "DT_NEEDED":
-                    if tag.needed == 'libc.so.6':
+                    if tag.needed == "libc.so.6":
                         libc = Libc.GLIBC
                         break
-                    if tag.needed.startswith('libc.musl-'):
+                    if tag.needed.startswith("libc.musl-"):
                         libc = Libc.MUSL
                         break
             break

src/auditwheel/main_repair.py

@@ -150,7 +150,7 @@ def execute(args, p):
                 'cannot repair "%s" to "%s" ABI because of the presence '
                 "of too-recent versioned symbols. You'll need to compile "
                 "the wheel on an older toolchain or pick a newer platform."
-                    % (wheel_file, args.PLAT)
+                % (wheel_file, args.PLAT)
             )
             p.error(msg)
 

src/auditwheel/musllinux.py

@@ -8,7 +8,7 @@
 from auditwheel.error import InvalidLibc
 
 LOG = logging.getLogger(__name__)
-VERSION_RE = re.compile(b'[^.](?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)\0')
+VERSION_RE = re.compile(b"[^.](?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)\0")
 
 
 class MuslVersion(NamedTuple):
@@ -28,14 +28,16 @@ def find_musl_libc(library_path: str | None = None) -> pathlib.Path | None:
 
 def get_musl_version(ld_path: pathlib.Path) -> MuslVersion | None:
     try:
-        with open(ld_path, 'rb') as fp:
+        with open(ld_path, "rb") as fp:
             text = fp.read()
     except FileNotFoundError:
         return None
 
     for match in VERSION_RE.finditer(text):
         return MuslVersion(
-            int(match.group("major")), int(match.group("minor")), int(match.group("patch"))
+            int(match.group("major")),
+            int(match.group("minor")),
+            int(match.group("patch")),
         )
 
     LOG.error("Failed to determine musl version", exc_info=True)

src/auditwheel/policy/__init__.py

@@ -1,19 +1,22 @@
 from __future__ import annotations
 
+import copy
 import json
 import logging
 import platform as _platform_module
 import re
 import struct
 import sys
-import copy
 from collections import defaultdict
 from os.path import abspath, dirname, join
 from pathlib import Path
 from typing import Any, Generator
 
-from auditwheel.elfutils import filter_undefined_symbols, is_subdir, \
-    elf_get_platform_info
+from auditwheel.elfutils import (
+    elf_get_platform_info,
+    filter_undefined_symbols,
+    is_subdir,
+)
 from auditwheel.wheeltools import InWheelCtx
 
 from ..libc import Libc, get_libc
@@ -64,15 +67,23 @@ def _reload_policies(self):
         if self._libc_variant is None:
             self._libc_variant = get_libc() if self._musl_policy is None else Libc.MUSL
 
-        if self._libc_variant is not None and self._libc_variant != Libc.MUSL and self._musl_policy is not None:
-            raise ValueError(f"'musl_policy' shall be None for libc {self._libc_variant.name}")
+        if (
+            self._libc_variant is not None
+            and self._libc_variant != Libc.MUSL
+            and self._musl_policy is not None
+        ):
+            raise ValueError(
+                f"'musl_policy' shall be None for libc {self._libc_variant.name}"
+            )
 
-        if self._libc_variant  == Libc.MUSL:
+        if self._libc_variant == Libc.MUSL:
             if self._musl_policy is None:
                 libc_path = find_musl_libc(self._library_path)
                 if libc_path is not None:
                     musl_version = get_musl_version(libc_path)
-                    self._musl_policy = f"musllinux_{musl_version.major}_{musl_version.minor}"
+                    self._musl_policy = (
+                        f"musllinux_{musl_version.major}_{musl_version.minor}"
+                    )
             elif _MUSL_POLICY_RE.match(self._musl_policy) is None:
                 raise ValueError(f"Invalid 'musl_policy': '{self._musl_policy}'")
 
@@ -87,12 +98,16 @@ def _reload_policies(self):
                     self._musl_policy,
                 }:
                     continue
-                versioning = policy["symbol_versions"] if policy["name"] != "linux" else {arch: [] for arch in ALL_ARCHES}
+                versioning = (
+                    policy["symbol_versions"]
+                    if policy["name"] != "linux"
+                    else {arch: [] for arch in ALL_ARCHES}
+                )
                 for arch, versions in versioning.items():
                     if self._arch_name is not None and self._arch_name != arch:
                         continue
                     archpolicy = copy.copy(policy)
-                    
+
                     archpolicy["arch"] = arch
                     if archpolicy["name"] != "linux":
                         archpolicy["symbol_versions"] = versions
@@ -141,7 +156,9 @@ def get_policy_by_name(self, name: str) -> dict | None:
             raise RuntimeError("Internal error. Policies should be unique")
         return matches[0]
 
-    def get_policy_name(self, priority: int, default_arch: str | None = None) -> str | None:
+    def get_policy_name(
+        self, priority: int, default_arch: str | None = None
+    ) -> str | None:
         matches = [p["name"] for p in self._policies if p["priority"] == priority]
         if len(matches) == 0:
             return None
@@ -165,7 +182,9 @@ def get_policy_name(self, priority: int, default_arch: str | None = None) -> str
                 if len(matches2) > 1:
                     raise RuntimeError("Internal error. Priorities should be unique.")
                 return matches2[0]
-        raise RuntimeError("Internal error. Every policy should have a known architecture.")
+        raise RuntimeError(
+            "Internal error. Every policy should have a known architecture."
+        )
 
     def get_priority_by_name(self, name: str) -> int | None:
         policy = self.get_policy_by_name(name)

tests/unit/test_musllinux.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import subprocess
-from unittest.mock import patch
 from io import BytesIO
+from unittest.mock import patch
 
 import pytest
 
@@ -29,7 +29,7 @@ def test_get_musl_version_invalid_path():
 
 @patch("auditwheel.musllinux.open")
 def test_get_musl_version_invalid_version(run_mock):
-    run_mock.return_value = BytesIO(b'jklasdfjkl Version 1.1')
+    run_mock.return_value = BytesIO(b"jklasdfjkl Version 1.1")
     assert get_musl_version("anything") is None