mypy: upgrade to 1.10.0

Signed-off-by: Achille Roussel <[email protected]>

Makefile

@@ -30,7 +30,7 @@ fmt-check:
     exit $$((isort_status + black_status))
 
 typecheck:
-	$(PYTHON) -m mypy src tests
+	$(PYTHON) -m mypy --check-untyped-defs src tests examples
 
 unittest:
 	$(PYTHON) -m pytest tests

pyproject.toml

@@ -26,7 +26,7 @@ lambda = ["awslambdaric"]
 dev = [
     "black >= 24.1.0",
     "isort >= 5.13.2",
-    "mypy >= 1.8.0",
+    "mypy >= 1.10.0",
     "pytest==8.0.0",
     "fastapi >= 0.109.0",
     "coverage >= 7.4.1",
@@ -58,7 +58,7 @@ src_paths = ["src"]
 omit = ["*_pb2_grpc.py", "*_pb2.py", "tests/*", "examples/*", "src/buf/*"]
 
 [tool.mypy]
-exclude = ['^src/buf', '^tests/examples']
+exclude = ['^src/buf', '^tests/examples', '^src/dispatch/sdk']
 
 [tool.pytest.ini_options]
 testpaths = ['tests']

src/dispatch/experimental/durable/function.py

@@ -137,13 +137,13 @@ def __getstate__(self):
             if frame_state < FRAME_CLEARED:
                 print(f"IP = {ip}")
                 print(f"SP = {sp}")
-                for i, (is_null, value) in enumerate(stack):
+                for i, (is_null, value) in enumerate(stack if stack is not None else []):
                     if is_null:
                         print(f"stack[{i}] = NULL")
                     else:
                         print(f"stack[{i}] = {value}")
                 print(f"BP = {bp}")
-                for i, block in enumerate(blocks):
+                for i, block in enumerate(blocks if blocks is not None else []):
                     print(f"block[{i}] = {block}")
             print()
 

src/dispatch/experimental/durable/registry.py

@@ -40,7 +40,9 @@ def __setstate__(self, state):
                 f"hash mismatch for function {key}: {code_hash} vs. expected {rfn.hash}"
             )
 
-        self.fn = rfn.fn
+        # mypy 1.10.0 seems to report a false positive here:
+        # error: Incompatible types in assignment (expression has type "FunctionType", variable has type "MethodType")  [assignment]
+        self.fn = rfn.fn # type: ignore
         self.key = key
         self.filename = filename
         self.lineno = lineno

src/dispatch/function.py

@@ -256,9 +256,9 @@ def primitive_func(input: Input) -> Output:
             return OneShotScheduler(func).run(input)
 
         primitive_func.__qualname__ = f"{name}_primitive"
-        primitive_func = durable(primitive_func)
+        durable_primitive_func = durable(primitive_func)
 
-        wrapped_func = Function[P, T](self.endpoint, self.client, name, primitive_func)
+        wrapped_func = Function[P, T](self.endpoint, self.client, name, durable_primitive_func)
         self._register(name, wrapped_func)
         return wrapped_func
 

src/dispatch/http.py

@@ -117,7 +117,7 @@ def do_POST(self):
             )
             max_age = timedelta(minutes=5)
             try:
-                verify_request(signed_request, verification_key, max_age)
+                verify_request(signed_request, self.verification_key, max_age)
             except ValueError as e:
                 self.send_error_response_unauthenticated(str(e))
                 return

src/dispatch/status.py

@@ -83,7 +83,7 @@ def __str__(self):
 _OUTPUT_TYPES: Dict[Type[Any], Callable[[Any], Status]] = {}
 
 
-def status_for_error(error: Exception) -> Status:
+def status_for_error(error: BaseException) -> Status:
     """Returns a Status that corresponds to the specified error."""
     # See if the error matches one of the registered types.
     handler = _find_handler(error, _ERROR_TYPES)

src/dispatch/test/service.py

@@ -87,9 +87,8 @@ def __init__(
         self.pollers: Dict[DispatchID, Poller] = {}
         self.parents: Dict[DispatchID, Poller] = {}
 
-        self.roundtrips: Optional[OrderedDict[DispatchID, List[RoundTrip]]] = None
-        if collect_roundtrips:
-            self.roundtrips = OrderedDict()
+        self.roundtrips: OrderedDict[DispatchID, List[RoundTrip]] = OrderedDict()
+        self.collect_roundtrips = collect_roundtrips
 
         self._thread: Optional[threading.Thread] = None
         self._stop_event = threading.Event()
@@ -142,7 +141,7 @@ def _make_dispatch_id(self) -> DispatchID:
     def dispatch_calls(self):
         """Synchronously dispatch pending function calls to the
         configured endpoint."""
-        _next_queue = []
+        _next_queue: List[Tuple[DispatchID, function_pb.RunRequest, CallType]] = []
         while self.queue:
             dispatch_id, request, call_type = self.queue.pop(0)
 
@@ -161,7 +160,7 @@ def dispatch_calls(self):
                 self.queue.append((dispatch_id, request, CallType.RETRY))
                 raise
 
-            if self.roundtrips is not None:
+            if self.collect_roundtrips:
                 try:
                     roundtrips = self.roundtrips[dispatch_id]
                 except KeyError:

tests/dispatch/signature/test_signature.py

@@ -146,58 +146,58 @@ def test_known_signature(self):
     @mock.patch.dict(os.environ, {"DISPATCH_VERIFICATION_KEY": public_key2_pem})
     def test_parse_verification_key_env_pem_str(self):
         verification_key = parse_verification_key(None)
-        self.assertIsInstance(verification_key, Ed25519PublicKey)
-        self.assertEqual(verification_key.public_bytes_raw(), public_key2_bytes)
+        assert isinstance(verification_key, Ed25519PublicKey)
+        assert verification_key.public_bytes_raw(), public_key2_bytes
 
     @mock.patch.dict(os.environ, {"DISPATCH_VERIFICATION_KEY": public_key2_pem2})
     def test_parse_verification_key_env_pem_escaped_newline_str(self):
         verification_key = parse_verification_key(None)
-        self.assertIsInstance(verification_key, Ed25519PublicKey)
-        self.assertEqual(verification_key.public_bytes_raw(), public_key2_bytes)
+        assert isinstance(verification_key, Ed25519PublicKey)
+        assert verification_key.public_bytes_raw(), public_key2_bytes
 
     @mock.patch.dict(
         os.environ, {"DISPATCH_VERIFICATION_KEY": public_key2_b64.decode()}
     )
     def test_parse_verification_key_env_b64_str(self):
         verification_key = parse_verification_key(None)
-        self.assertIsInstance(verification_key, Ed25519PublicKey)
-        self.assertEqual(verification_key.public_bytes_raw(), public_key2_bytes)
+        assert isinstance(verification_key, Ed25519PublicKey)
+        assert verification_key.public_bytes_raw() == public_key2_bytes
 
     def test_parse_verification_key_none(self):
         # The verification key is optional. Both Dispatch(verification_key=...) and
         # DISPATCH_VERIFICATION_KEY may be omitted/None.
         verification_key = parse_verification_key(None)
-        self.assertIsNone(verification_key)
+        assert verification_key is None
 
     def test_parse_verification_key_ed25519publickey(self):
         verification_key = parse_verification_key(public_key2)
-        self.assertIsInstance(verification_key, Ed25519PublicKey)
-        self.assertEqual(verification_key.public_bytes_raw(), public_key2_bytes)
+        assert isinstance(verification_key, Ed25519PublicKey)
+        assert verification_key.public_bytes_raw() == public_key2_bytes
 
     def test_parse_verification_key_pem_str(self):
         verification_key = parse_verification_key(public_key2_pem)
-        self.assertIsInstance(verification_key, Ed25519PublicKey)
-        self.assertEqual(verification_key.public_bytes_raw(), public_key2_bytes)
+        assert isinstance(verification_key, Ed25519PublicKey)
+        assert verification_key.public_bytes_raw() == public_key2_bytes
 
     def test_parse_verification_key_pem_escaped_newline_str(self):
         verification_key = parse_verification_key(public_key2_pem2)
-        self.assertIsInstance(verification_key, Ed25519PublicKey)
-        self.assertEqual(verification_key.public_bytes_raw(), public_key2_bytes)
+        assert isinstance(verification_key, Ed25519PublicKey)
+        assert verification_key.public_bytes_raw() == public_key2_bytes
 
     def test_parse_verification_key_pem_bytes(self):
         verification_key = parse_verification_key(public_key2_pem.encode())
-        self.assertIsInstance(verification_key, Ed25519PublicKey)
-        self.assertEqual(verification_key.public_bytes_raw(), public_key2_bytes)
+        assert isinstance(verification_key, Ed25519PublicKey)
+        assert verification_key.public_bytes_raw() == public_key2_bytes
 
     def test_parse_verification_key_b64_str(self):
         verification_key = parse_verification_key(public_key2_b64.decode())
-        self.assertIsInstance(verification_key, Ed25519PublicKey)
-        self.assertEqual(verification_key.public_bytes_raw(), public_key2_bytes)
+        assert isinstance(verification_key, Ed25519PublicKey)
+        assert verification_key.public_bytes_raw() == public_key2_bytes
 
     def test_parse_verification_key_b64_bytes(self):
         verification_key = parse_verification_key(public_key2_b64)
-        self.assertIsInstance(verification_key, Ed25519PublicKey)
-        self.assertEqual(verification_key.public_bytes_raw(), public_key2_bytes)
+        assert isinstance(verification_key, Ed25519PublicKey)
+        assert verification_key.public_bytes_raw() == public_key2_bytes
 
     def test_parse_verification_key_invalid(self):
         with self.assertRaisesRegex(ValueError, "invalid verification key 'foo'"):

tests/dispatch/test_error.py

@@ -65,7 +65,7 @@ def test_conversion_without_traceback(self):
             original_exception = e
 
         error = Error.from_exception(original_exception)
-        error.traceback = ""
+        error.traceback = b""
 
         reconstructed_exception = error.to_exception()
         assert type(reconstructed_exception) is type(original_exception)

tests/dispatch/test_scheduler.py

@@ -255,7 +255,7 @@ async def main():
             result3 = await call_concurrently("g", "h")
             return [result1, result2, result3]
 
-        correlation_ids = set()
+        correlation_ids: set[int] = set()
 
         output = self.start(main)
         # a, b, c, d are called first. e is not because it depends on a.

tests/test_fastapi.py

@@ -465,10 +465,6 @@ def get(path: str) -> httpx.Response:
 
 
 class TestError(unittest.TestCase):
-    def test_missing_type_and_message(self):
-        with self.assertRaises(ValueError):
-            Error(Status.TEMPORARY_ERROR, type=None, message=None)
-
     def test_error_with_ok_status(self):
         with self.assertRaises(ValueError):
             Error(Status.OK, type="type", message="yep")

tests/test_http.py

@@ -72,7 +72,7 @@ def test_content_length_missing(self):
     def test_content_length_too_large(self):
         resp = self.client.post(
             f"{self.endpoint}/dispatch.sdk.v1.FunctionService/Run",
-            data=b"a" * 16_000_001,
+            data={"msg": "a" * 16_000_001},
         )
         body = resp.read()
         self.assertEqual(resp.status_code, 400)