chore: work through remaining types

Signed-off-by: Henry Schreiner <[email protected]>

Author: henryiii

src/packaging/markers.py

@@ -8,7 +8,7 @@
 import os
 import platform
 import sys
-from typing import AbstractSet, Any, Callable, Literal, TypedDict, Union, cast
+from typing import AbstractSet, Any, Callable, Literal, Mapping, TypedDict, Union, cast
 
 from ._parser import MarkerAtom, MarkerList, Op, Value, Variable
 from ._parser import parse_marker as _parse_marker
@@ -314,7 +314,7 @@ def __eq__(self, other: object) -> bool:
 
     def evaluate(
         self,
-        environment: dict[str, str] | None = None,
+        environment: Mapping[str, str | AbstractSet[str]] | None = None,
         context: EvaluateContext = "metadata",
     ) -> bool:
         """Evaluate a marker.

tests/test_elffile.py

@@ -22,7 +22,9 @@
         ("s390x-s390x", EIClass.C64, EIData.Msb, EMachine.S390),
     ],
 )
-def test_elffile_glibc(name, capacity, encoding, machine) -> None:
+def test_elffile_glibc(
+    name: str, capacity: EIClass, encoding: EIData, machine: EMachine
+) -> None:
     path = DIR_MANYLINUX.joinpath(f"hello-world-{name}")
     with path.open("rb") as f:
         ef = ELFFile(f)
@@ -46,7 +48,9 @@ def test_elffile_glibc(name, capacity, encoding, machine) -> None:
         ("x86_64", EIClass.C64, EIData.Lsb, EMachine.X8664, "x86_64"),
     ],
 )
-def test_elffile_musl(name, capacity, encoding, machine, interpreter) -> None:
+def test_elffile_musl(
+    name: str, capacity: EIClass, encoding: EIData, machine: EMachine, interpreter: str
+) -> None:
     path = DIR_MUSLLINUX.joinpath(f"musl-{name}")
     with path.open("rb") as f:
         ef = ELFFile(f)
@@ -68,7 +72,7 @@ def test_elffile_musl(name, capacity, encoding, machine, interpreter) -> None:
     ],
     ids=["no-magic", "wrong-magic", "unknown-format"],
 )
-def test_elffile_bad_ident(data) -> None:
+def test_elffile_bad_ident(data: bytes) -> None:
     with pytest.raises(ELFInvalid):
         ELFFile(io.BytesIO(data))
 

tests/test_manylinux.py

@@ -1,13 +1,19 @@
+from __future__ import annotations
+
 try:
     import ctypes
 except ImportError:
-    ctypes = None
+    ctypes = None  # type: ignore[assignment]
 import os
 import pathlib
 import platform
 import re
 import sys
 import types
+import typing
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Generator
 
 import pretend
 import pytest
@@ -18,20 +24,21 @@
     _glibc_version_string,
     _glibc_version_string_confstr,
     _glibc_version_string_ctypes,
+    _GLibCVersion,
     _is_compatible,
     _parse_elf,
     _parse_glibc_version,
 )
 
 
 @pytest.fixture(autouse=True)
-def clear_lru_cache():
+def clear_lru_cache() -> Generator[None, None, None]:
     yield
     _get_glibc_version.cache_clear()
 
 
 @pytest.fixture
-def manylinux_module(monkeypatch: pytest.MonkeyPatch):
+def manylinux_module(monkeypatch: pytest.MonkeyPatch) -> types.ModuleType:
     monkeypatch.setattr(_manylinux, "_get_glibc_version", lambda *args: (2, 20))
     module_name = "_manylinux"
     module = types.ModuleType(module_name)
@@ -44,44 +51,54 @@ def manylinux_module(monkeypatch: pytest.MonkeyPatch):
     ("attribute", "glibc"), [("1", (2, 5)), ("2010", (2, 12)), ("2014", (2, 17))]
 )
 def test_module_declaration(
-    monkeypatch: pytest.MonkeyPatch, manylinux_module, attribute, glibc, tf
+    monkeypatch: pytest.MonkeyPatch,
+    manylinux_module: types.ModuleType,
+    attribute: str,
+    glibc: tuple[int, int],
+    tf: bool,
 ) -> None:
     manylinux = f"manylinux{attribute}_compatible"
     monkeypatch.setattr(manylinux_module, manylinux, tf, raising=False)
-    res = _is_compatible("x86_64", glibc)
+    glibc_version = _GLibCVersion(glibc[0], glibc[1])
+    res = _is_compatible("x86_64", glibc_version)
     assert tf is res
 
 
 @pytest.mark.parametrize(
     ("attribute", "glibc"), [("1", (2, 5)), ("2010", (2, 12)), ("2014", (2, 17))]
 )
 def test_module_declaration_missing_attribute(
-    monkeypatch: pytest.MonkeyPatch, manylinux_module, attribute, glibc
-):
+    monkeypatch: pytest.MonkeyPatch,
+    manylinux_module: types.ModuleType,
+    attribute: str,
+    glibc: tuple[int, int],
+) -> None:
     manylinux = f"manylinux{attribute}_compatible"
     monkeypatch.delattr(manylinux_module, manylinux, raising=False)
-    assert _is_compatible("x86_64", glibc)
+    glibc_version = _GLibCVersion(glibc[0], glibc[1])
+    assert _is_compatible("x86_64", glibc_version)
 
 
 @pytest.mark.parametrize(
     ("version", "compatible"), [((2, 0), True), ((2, 5), True), ((2, 10), False)]
 )
 def test_is_manylinux_compatible_glibc_support(
-    version, compatible, monkeypatch: pytest.MonkeyPatch
+    version: tuple[int, int], compatible: bool, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     monkeypatch.setitem(sys.modules, "_manylinux", None)
     monkeypatch.setattr(_manylinux, "_get_glibc_version", lambda: (2, 5))
-    assert bool(_is_compatible("any", version)) == compatible
+    glibc_version = _GLibCVersion(version[0], version[1])
+    assert bool(_is_compatible("any", glibc_version)) == compatible
 
 
 @pytest.mark.parametrize("version_str", ["glibc-2.4.5", "2"])
-def test_check_glibc_version_warning(version_str) -> None:
+def test_check_glibc_version_warning(version_str: str) -> None:
     msg = f"Expected glibc version with 2 components major.minor, got: {version_str}"
     with pytest.warns(RuntimeWarning, match=re.escape(msg)):
         _parse_glibc_version(version_str)
 
 
-@pytest.mark.skipif(not ctypes, reason="requires ctypes")
+@pytest.mark.skipif(not ctypes, reason="requires ctypes")  # type: ignore[truthy-bool]
 @pytest.mark.parametrize(
     ("version_str", "expected"),
     [
@@ -91,17 +108,17 @@ def test_check_glibc_version_warning(version_str) -> None:
     ],
 )
 def test_glibc_version_string(
-    version_str, expected, monkeypatch: pytest.MonkeyPatch
+    version_str: str | bytes, expected: str, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     class LibcVersion:
-        def __init__(self, version_str):
+        def __init__(self, version_str: str | bytes) -> None:
             self.version_str = version_str
 
-        def __call__(self):
-            return version_str
+        def __call__(self) -> str | bytes:
+            return self.version_str
 
     class ProcessNamespace:
-        def __init__(self, libc_version):
+        def __init__(self, libc_version: LibcVersion) -> None:
             self.gnu_get_libc_version = libc_version
 
     process_namespace = ProcessNamespace(LibcVersion(version_str))
@@ -131,7 +148,7 @@ def test_glibc_version_string_fail(monkeypatch: pytest.MonkeyPatch) -> None:
     [pretend.raiser(ValueError), pretend.raiser(OSError), lambda _: "XXX"],
 )
 def test_glibc_version_string_confstr_fail(
-    monkeypatch: pytest.MonkeyPatch, failure
+    monkeypatch: pytest.MonkeyPatch, failure: typing.Callable[[int], str | None]
 ) -> None:
     monkeypatch.setattr(os, "confstr", failure, raising=False)
     assert _glibc_version_string_confstr() is None
@@ -151,7 +168,7 @@ def test_glibc_version_string_ctypes_missing(monkeypatch: pytest.MonkeyPatch) ->
 def test_glibc_version_string_ctypes_raise_oserror(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    def patched_cdll(_name):
+    def patched_cdll(_name: str) -> None:
         raise OSError("Dynamic loading not supported")
 
     monkeypatch.setattr(ctypes, "CDLL", patched_cdll)
@@ -162,27 +179,29 @@ def patched_cdll(_name):
 def test_is_manylinux_compatible_old() -> None:
     # Assuming no one is running this test with a version of glibc released in
     # 1997.
-    assert _is_compatible("any", (2, 0))
+    assert _is_compatible("any", _GLibCVersion(2, 0))
 
 
 def test_is_manylinux_compatible(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(_manylinux, "_glibc_version_string", lambda: "2.4")
-    assert _is_compatible("any", (2, 4))
+    assert _is_compatible("any", _GLibCVersion(2, 4))
 
 
 def test_glibc_version_string_none(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(_manylinux, "_glibc_version_string", lambda: None)
-    assert not _is_compatible("any", (2, 4))
+    assert not _is_compatible("any", _GLibCVersion(2, 4))
 
 
 @pytest.mark.parametrize(
     "content", [None, "invalid-magic", "invalid-class", "invalid-data", "too-short"]
 )
-def test_parse_elf_bad_executable(content) -> None:
+def test_parse_elf_bad_executable(content: str | None) -> None:
+    path_str: str | None
     if content:
         path = pathlib.Path(__file__).parent / "manylinux" / f"hello-world-{content}"
-        path = os.fsdecode(path)
+        path_str = os.fsdecode(path)
     else:
-        path = None
-    with _parse_elf(path) as ef:
+        path_str = None
+    # None is not supported in the type annotation, but it was tested before.
+    with _parse_elf(path_str) as ef:  # type: ignore[arg-type]
         assert ef is None

tests/test_markers.py

@@ -2,6 +2,8 @@
 # 2.0, and the BSD License. See the LICENSE file in the root of this repository
 # for complete details.
 
+from __future__ import annotations
+
 import collections
 import itertools
 import os
@@ -60,15 +62,15 @@
 
 class TestNode:
     @pytest.mark.parametrize("value", ["one", "two", None, 3, 5, []])
-    def test_accepts_value(self, value) -> None:
-        assert Node(value).value == value
+    def test_accepts_value(self, value: str | None | int | list[str]) -> None:
+        assert Node(value).value == value  # type: ignore[arg-type]
 
     @pytest.mark.parametrize("value", ["one", "two"])
-    def test_str(self, value) -> None:
+    def test_str(self, value: str) -> None:
         assert str(Node(value)) == str(value)
 
     @pytest.mark.parametrize("value", ["one", "two"])
-    def test_repr(self, value) -> None:
+    def test_repr(self, value: str) -> None:
         assert repr(Node(value)) == f"<Node({str(value)!r})>"
 
     def test_base_class(self) -> None:
@@ -141,11 +143,11 @@ def test_multidigit_minor_version(self, monkeypatch: pytest.MonkeyPatch) -> None
 
     def tests_when_releaselevel_final(self) -> None:
         v = FakeVersionInfo(3, 4, 2, "final", 0)
-        assert format_full_version(v) == "3.4.2"
+        assert format_full_version(v) == "3.4.2"  # type: ignore[arg-type]
 
     def tests_when_releaselevel_not_final(self) -> None:
         v = FakeVersionInfo(3, 4, 2, "beta", 4)
-        assert format_full_version(v) == "3.4.2b4"
+        assert format_full_version(v) == "3.4.2b4"  # type: ignore[arg-type]
 
 
 class TestMarker:
@@ -160,7 +162,7 @@ class TestMarker:
             for i in itertools.product(VARIABLES, OPERATORS, VALUES)
         ],
     )
-    def test_parses_valid(self, marker_string) -> None:
+    def test_parses_valid(self, marker_string: str) -> None:
         Marker(marker_string)
 
     @pytest.mark.parametrize(
@@ -174,7 +176,7 @@ def test_parses_valid(self, marker_string) -> None:
             '(python_version == "2.7") with random text',
         ],
     )
-    def test_parses_invalid(self, marker_string) -> None:
+    def test_parses_invalid(self, marker_string: str) -> None:
         with pytest.raises(InvalidMarker):
             Marker(marker_string)
 
@@ -213,7 +215,7 @@ def test_parses_invalid(self, marker_string) -> None:
             ),
         ],
     )
-    def test_str_repr_eq_hash(self, marker_string, expected) -> None:
+    def test_str_repr_eq_hash(self, marker_string: str, expected: str) -> None:
         m = Marker(marker_string)
         assert str(m) == expected
         assert repr(m) == f"<Marker({str(m)!r})>"
@@ -248,7 +250,9 @@ def test_str_repr_eq_hash(self, marker_string, expected) -> None:
             ),
         ],
     )
-    def test_different_markers_different_hashes(self, example1, example2) -> None:
+    def test_different_markers_different_hashes(
+        self, example1: str, example2: str
+    ) -> None:
         marker1, marker2 = Marker(example1), Marker(example2)
         # Markers created from strings that are not equivalent should differ.
         assert marker1 != marker2
@@ -316,8 +320,10 @@ def test_environment_with_extra_none(self) -> None:
             ),
         ],
     )
-    def test_evaluates(self, marker_string, environment, expected) -> None:
-        args = [] if environment is None else [environment]
+    def test_evaluates(
+        self, marker_string: str, environment: dict[str, str] | None, expected: bool
+    ) -> None:
+        args = () if environment is None else (environment,)
         assert Marker(marker_string).evaluate(*args) == expected
 
     @pytest.mark.parametrize(
@@ -331,7 +337,7 @@ def test_evaluates(self, marker_string, environment, expected) -> None:
             for i in itertools.product(PEP_345_VARIABLES, OPERATORS, VALUES)
         ],
     )
-    def test_parses_pep345_valid(self, marker_string) -> None:
+    def test_parses_pep345_valid(self, marker_string: str) -> None:
         Marker(marker_string)
 
     @pytest.mark.parametrize(
@@ -354,9 +360,9 @@ def test_parses_pep345_valid(self, marker_string) -> None:
         ],
     )
     def test_evaluate_pep345_markers(
-        self, marker_string, environment, expected
+        self, marker_string: str, environment: dict[str, str] | None, expected: bool
     ) -> None:
-        args = [] if environment is None else [environment]
+        args = () if environment is None else (environment,)
         assert Marker(marker_string).evaluate(*args) == expected
 
     @pytest.mark.parametrize(
@@ -370,12 +376,12 @@ def test_evaluate_pep345_markers(
             for i in itertools.product(SETUPTOOLS_VARIABLES, OPERATORS, VALUES)
         ],
     )
-    def test_parses_setuptools_legacy_valid(self, marker_string) -> None:
+    def test_parses_setuptools_legacy_valid(self, marker_string: str) -> None:
         Marker(marker_string)
 
     def test_evaluate_setuptools_legacy_markers(self) -> None:
         marker_string = "python_implementation=='Jython'"
-        args = [{"platform_python_implementation": "CPython"}]
+        args = ({"platform_python_implementation": "CPython"},)
         assert Marker(marker_string).evaluate(*args) is False
 
     def test_extra_str_normalization(self) -> None:
@@ -414,12 +420,14 @@ def test_python_full_version_untagged(self) -> None:
             pytest.param('"Foo" in {0}', True, id="case-sensitive"),
         ],
     )
-    def test_extras_and_dependency_groups(self, variable, expression, result) -> None:
+    def test_extras_and_dependency_groups(
+        self, variable: str, expression: str, result: bool
+    ) -> None:
         environment = {variable: {"foo", "bar"}}
         assert Marker(expression.format(variable)).evaluate(environment) == result
 
     @pytest.mark.parametrize("variable", ["extras", "dependency_groups"])
-    def test_extras_and_dependency_groups_disallowed(self, variable) -> None:
+    def test_extras_and_dependency_groups_disallowed(self, variable: str) -> None:
         marker = Marker(f'"foo" in {variable}')
         assert not marker.evaluate(context="lock_file")