Strict typing

conftest.py

@@ -1,14 +1,14 @@
-import sys
 import re
+import sys
 
 import jaraco.functools
 
 
-def pytest_configure():
+def pytest_configure() -> None:
     patch_for_issue_12()
 
 
-def patch_for_issue_12():  # pragma: nocover
+def patch_for_issue_12() -> None:  # pragma: nocover
     """
     Issue #12 revealed that Python 3.7.3 had a subtle
     change in the C implementation of functools that
@@ -21,4 +21,4 @@ def patch_for_issue_12():  # pragma: nocover
     if sys.version_info[:3] != affected_ver:
         return
     mc = jaraco.functools.method_cache
-    mc.__doc__ = re.sub(r'^(\s+)75', r'\g<1>76', mc.__doc__, flags=re.M)
+    mc.__doc__ = re.sub(r'^(\s+)75', r'\g<1>76', mc.__doc__ or "", flags=re.M)

mypy.ini

@@ -1,6 +1,6 @@
 [mypy]
 # Is the project well-typed?
-strict = False
+strict = True
 
 # Early opt-in even when strict = False
 warn_unused_ignores = True

pyproject.toml

@@ -70,7 +70,3 @@ type = [
 
 
 [tool.setuptools_scm]
-
-
-[tool.pytest-enabler.mypy]
-# Disabled due to jaraco/skeleton#143

test_functools.py

@@ -1,25 +1,29 @@
-import os
-import itertools
-import time
+from __future__ import annotations
+
 import copy
-import random
 import functools
+import itertools
+import os
 import platform
+import random
+import time
+from typing import Literal, TypeVar
 from unittest import mock
 
 import pytest
+
 from jaraco.classes import properties
+from jaraco.functools import Throttler, method_cache, retry, retry_call
 
-from jaraco.functools import Throttler, method_cache, retry_call, retry
+_T = TypeVar("_T")
 
 
 class TestThrottler:
     @pytest.mark.xfail(
-        os.environ.get('GITHUB_ACTIONS')  # type: ignore
-        and platform.system() in ('Darwin', 'Windows'),
+        'GITHUB_ACTIONS' in os.environ and platform.system() in ('Darwin', 'Windows'),
         reason="Performance is heavily throttled on Github Actions Mac/Windows runs",
     )
-    def test_function_throttled(self):
+    def test_function_throttled(self) -> None:
         """
         Ensure the throttler actually throttles calls.
         """
@@ -43,7 +47,7 @@ def test_function_throttled(self):
             limited_next(counter)
         assert 28 <= next(counter) <= 32
 
-    def test_reconstruct_unwraps(self):
+    def test_reconstruct_unwraps(self) -> None:
         """
         The throttler should be re-usable - if one wants to throttle a
         function that's aready throttled, the original function should be
@@ -54,10 +58,10 @@ def test_reconstruct_unwraps(self):
         assert wrapped_again.func is next
         assert wrapped_again.max_rate == 60
 
-    def test_throttled_method(self):
+    def test_throttled_method(self) -> None:
         class ThrottledMethodClass:
             @Throttler
-            def echo(self, arg):
+            def echo(self, arg: _T) -> _T:
                 return arg
 
         tmc = ThrottledMethodClass()
@@ -68,7 +72,7 @@ class TestMethodCache:
     bad_vers = '(3, 5, 0) <= sys.version_info < (3, 5, 2)'
 
     @pytest.mark.skipif(bad_vers, reason="https://bugs.python.org/issue25447")
-    def test_deepcopy(self):
+    def test_deepcopy(self) -> None:
         """
         A deepcopy of an object with a method cache should still
         succeed.
@@ -78,7 +82,7 @@ class ClassUnderTest:
             calls = 0
 
             @method_cache
-            def method(self, value):
+            def method(self, value: _T) -> _T:
                 self.calls += 1
                 return value
 
@@ -87,7 +91,7 @@ def method(self, value):
         ob.method(1)
         copy.deepcopy(ob)
 
-    def test_special_methods(self):
+    def test_special_methods(self) -> None:
         """
         Test method_cache with __getitem__ and __getattr__.
         """
@@ -97,12 +101,12 @@ class ClassUnderTest:
             getattr_calls = 0
 
             @method_cache
-            def __getitem__(self, item):
+            def __getitem__(self, item: _T) -> _T:
                 self.getitem_calls += 1
                 return item
 
             @method_cache
-            def __getattr__(self, name):
+            def __getattr__(self, name: _T) -> _T:
                 self.getattr_calls += 1
                 return name
 
@@ -113,27 +117,27 @@ def __getattr__(self, name):
         assert ob.getitem_calls == 1
 
         # __getattr__
-        ob.one + ob.one
+        ob.one + ob.one  # type: ignore[operator] # Using ParamSpec on methods is still limited
         assert ob.getattr_calls == 1
 
     @pytest.mark.xfail(reason="can't replace property with cache; #6")
-    def test_property(self):
+    def test_property(self) -> None:
         """
         Can a method_cache decorated method also be a property?
         """
 
         class ClassUnderTest:
             @property
             @method_cache
-            def mything(self):  # pragma: nocover
+            def mything(self) -> float:  # pragma: nocover
                 return random.random()
 
         ob = ClassUnderTest()
 
         assert ob.mything == ob.mything
 
     @pytest.mark.xfail(reason="can't replace property with cache; #6")
-    def test_non_data_property(self):
+    def test_non_data_property(self) -> None:
         """
         A non-data property also does not work because the property
         gets replaced with a method.
@@ -142,7 +146,7 @@ def test_non_data_property(self):
         class ClassUnderTest:
             @properties.NonDataProperty
             @method_cache
-            def mything(self):
+            def mything(self) -> float:
                 return random.random()
 
         ob = ClassUnderTest()
@@ -151,17 +155,17 @@ def mything(self):
 
 
 class TestRetry:
-    def attempt(self, arg=None):
+    def attempt(self, arg: mock.Mock | None = None) -> Literal['Success']:
         if next(self.fails_left):
             raise ValueError("Failed!")
         if arg:
             arg.touch()
         return "Success"
 
-    def set_to_fail(self, times):
+    def set_to_fail(self, times: int) -> None:
         self.fails_left = itertools.count(times, -1)
 
-    def test_set_to_fail(self):
+    def test_set_to_fail(self) -> None:
         """
         Test this test's internal failure mechanism.
         """
@@ -172,12 +176,12 @@ def test_set_to_fail(self):
             self.attempt()
         assert self.attempt() == 'Success'
 
-    def test_retry_call_succeeds(self):
+    def test_retry_call_succeeds(self) -> None:
         self.set_to_fail(times=2)
         res = retry_call(self.attempt, retries=2, trap=ValueError)
         assert res == "Success"
 
-    def test_retry_call_fails(self):
+    def test_retry_call_fails(self) -> None:
         """
         Failing more than the number of retries should
         raise the underlying error.
@@ -187,56 +191,56 @@ def test_retry_call_fails(self):
             retry_call(self.attempt, retries=2, trap=ValueError)
         assert str(res.value) == 'Failed!'
 
-    def test_retry_multiple_exceptions(self):
+    def test_retry_multiple_exceptions(self) -> None:
         self.set_to_fail(times=2)
         errors = ValueError, NameError
         res = retry_call(self.attempt, retries=2, trap=errors)
         assert res == "Success"
 
-    def test_retry_exception_superclass(self):
+    def test_retry_exception_superclass(self) -> None:
         self.set_to_fail(times=2)
         res = retry_call(self.attempt, retries=2, trap=Exception)
         assert res == "Success"
 
-    def test_default_traps_nothing(self):
+    def test_default_traps_nothing(self) -> None:
         self.set_to_fail(times=1)
         with pytest.raises(ValueError):
             retry_call(self.attempt, retries=1)
 
-    def test_default_does_not_retry(self):
+    def test_default_does_not_retry(self) -> None:
         self.set_to_fail(times=1)
         with pytest.raises(ValueError):
             retry_call(self.attempt, trap=Exception)
 
-    def test_cleanup_called_on_exception(self):
+    def test_cleanup_called_on_exception(self) -> None:
         calls = random.randint(1, 10)
         cleanup = mock.Mock()
         self.set_to_fail(times=calls)
         retry_call(self.attempt, retries=calls, cleanup=cleanup, trap=Exception)
         assert cleanup.call_count == calls
         cleanup.assert_called_with()
 
-    def test_infinite_retries(self):
+    def test_infinite_retries(self) -> None:
         self.set_to_fail(times=999)
         cleanup = mock.Mock()
         retry_call(self.attempt, retries=float('inf'), cleanup=cleanup, trap=Exception)
         assert cleanup.call_count == 999
 
-    def test_with_arg(self):
+    def test_with_arg(self) -> None:
         self.set_to_fail(times=0)
         arg = mock.Mock()
         bound = functools.partial(self.attempt, arg)
         res = retry_call(bound)
         assert res == 'Success'
         assert arg.touch.called
 
-    def test_decorator(self):
+    def test_decorator(self) -> None:
         self.set_to_fail(times=1)
         attempt = retry(retries=1, trap=Exception)(self.attempt)
         res = attempt()
         assert res == "Success"
 
-    def test_decorator_with_arg(self):
+    def test_decorator_with_arg(self) -> None:
         self.set_to_fail(times=0)
         attempt = retry()(self.attempt)
         arg = mock.Mock()