fix: add type annotations for dynamically imported test modules

Add explicit type annotations to help ty type checker understand
dynamically imported modules (dto and serialization). Use cast() for
decoded JSON/msgpack objects to satisfy type checker.

Resolves 9 ty type checking errors:
- unresolved-attribute for dto.config
- unresolved-attribute for serialization module attributes
- non-subscriptable for decoded JSON/msgpack results

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: JacobCoffee

package.json

@@ -8,6 +8,7 @@
     "tailwindcss": "^3.3.3"
   },
   "devDependencies": {
+    "@biomejs/biome": "2.3.7",
     "daisyui": "^3.5.0"
   }
 }

tests/unit/api/test_dto.py

@@ -5,17 +5,21 @@
 import importlib.util
 import sys
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from litestar.dto import DTOConfig
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 # Import the dto module directly without triggering __init__.py
 dto_path = Path(__file__).parent.parent.parent.parent / "services" / "api" / "src" / "byte_api" / "lib" / "dto.py"
 spec = importlib.util.spec_from_file_location("dto", dto_path)
 dto = importlib.util.module_from_spec(spec)  # type: ignore[arg-type]
 sys.modules["dto"] = dto
 spec.loader.exec_module(dto)  # type: ignore[union-attr]
 
-config = dto.config
+config: Callable[..., DTOConfig] = dto.config  # type: ignore[attr-defined]
 
 __all__ = [
     "TestDTOConfig",

tests/unit/api/test_serialization.py

@@ -7,11 +7,16 @@
 import sys
 from json import dumps as json_dumps
 from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
 from uuid import uuid4
 
 import pytest
 from pydantic import BaseModel
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from json import JSONEncoder
+
 # Import the serialization module directly without triggering __init__.py
 serialization_path = (
     Path(__file__).parent.parent.parent.parent / "services" / "api" / "src" / "byte_api" / "lib" / "serialization.py"
@@ -21,14 +26,14 @@
 sys.modules["serialization"] = serialization
 spec.loader.exec_module(serialization)  # type: ignore[union-attr]
 
-UUIDEncoder = serialization.UUIDEncoder
-convert_camel_to_snake_case = serialization.convert_camel_to_snake_case
-convert_datetime_to_gmt = serialization.convert_datetime_to_gmt
-convert_string_to_camel_case = serialization.convert_string_to_camel_case
-from_json = serialization.from_json
-from_msgpack = serialization.from_msgpack
-to_json = serialization.to_json
-to_msgpack = serialization.to_msgpack
+UUIDEncoder: type[JSONEncoder] = serialization.UUIDEncoder  # type: ignore[attr-defined]
+convert_camel_to_snake_case: Callable[[str], str] = serialization.convert_camel_to_snake_case  # type: ignore[attr-defined]
+convert_datetime_to_gmt: Callable[[datetime.datetime], str] = serialization.convert_datetime_to_gmt  # type: ignore[attr-defined]
+convert_string_to_camel_case: Callable[[str], str] = serialization.convert_string_to_camel_case  # type: ignore[attr-defined]
+from_json: Callable[..., object] = serialization.from_json  # type: ignore[attr-defined]
+from_msgpack: Callable[..., object] = serialization.from_msgpack  # type: ignore[attr-defined]
+to_json: Callable[..., str] = serialization.to_json  # type: ignore[attr-defined]
+to_msgpack: Callable[..., bytes] = serialization.to_msgpack  # type: ignore[attr-defined]
 
 __all__ = [
     "TestCaseConversion",
@@ -82,7 +87,7 @@ def test_roundtrip_json(self) -> None:
         """Test JSON encode/decode roundtrip."""
         original = {"test": "data", "nested": {"value": 123}}
         encoded = to_json(original)
-        decoded = from_json(encoded)
+        decoded = cast(dict[str, Any], from_json(encoded))
 
         assert decoded == original
 
@@ -127,7 +132,7 @@ def test_to_json_with_deeply_nested_structures(self) -> None:
         result = to_json(nested)
 
         assert isinstance(result, bytes)
-        decoded = from_json(result)
+        decoded = cast(dict[str, Any], from_json(result))
         assert decoded["a"]["b"]["c"]["d"]["e"] == "deep"
 
     def test_to_json_with_mixed_nested_types(self) -> None:
@@ -140,15 +145,15 @@ def test_to_json_with_mixed_nested_types(self) -> None:
         result = to_json(data)
 
         assert isinstance(result, bytes)
-        decoded = from_json(result)
+        decoded = cast(dict[str, Any], from_json(result))
         assert decoded == data
 
     def test_to_json_with_empty_structures(self) -> None:
         """Test encoding empty dicts and lists."""
         data = {"empty_dict": {}, "empty_list": [], "nested_empty": {"a": []}}
         result = to_json(data)
 
-        decoded = from_json(result)
+        decoded = cast(dict[str, Any], from_json(result))
         assert decoded == data
 
     def test_to_json_with_special_characters(self) -> None:
@@ -161,15 +166,15 @@ def test_to_json_with_special_characters(self) -> None:
         }
         result = to_json(data)
 
-        decoded = from_json(result)
+        decoded = cast(dict[str, Any], from_json(result))
         assert decoded == data
 
     def test_to_json_with_boolean_and_null(self) -> None:
         """Test encoding boolean and null values."""
         data = {"true_val": True, "false_val": False, "null_val": None}
         result = to_json(data)
 
-        decoded = from_json(result)
+        decoded = cast(dict[str, Any], from_json(result))
         assert decoded == data
 
     def test_to_json_with_large_numbers(self) -> None:
@@ -181,7 +186,7 @@ def test_to_json_with_large_numbers(self) -> None:
         }
         result = to_json(data)
 
-        decoded = from_json(result)
+        decoded = cast(dict[str, Any], from_json(result))
         assert decoded == data
 
 
@@ -207,7 +212,7 @@ def test_roundtrip_msgpack(self) -> None:
         """Test MessagePack encode/decode roundtrip."""
         original = {"test": "data", "nested": {"value": 123}, "array": [1, 2, 3]}
         encoded = to_msgpack(original)
-        decoded = from_msgpack(encoded)
+        decoded = cast(dict[str, Any], from_msgpack(encoded))
 
         assert decoded == original
 
@@ -229,31 +234,31 @@ def test_to_msgpack_with_binary_data(self) -> None:
         result = to_msgpack(data)
 
         assert isinstance(result, bytes)
-        decoded = from_msgpack(result)
+        decoded = cast(dict[str, Any], from_msgpack(result))
         assert decoded == data
 
     def test_to_msgpack_with_deeply_nested_structures(self) -> None:
         """Test MessagePack with deeply nested structures."""
         nested = {"a": {"b": {"c": {"d": [1, 2, 3]}}}}
         result = to_msgpack(nested)
 
-        decoded = from_msgpack(result)
+        decoded = cast(dict[str, Any], from_msgpack(result))
         assert decoded == nested
 
     def test_to_msgpack_with_empty_structures(self) -> None:
         """Test MessagePack with empty dicts and lists."""
         data = {"empty": {}, "list": [], "nested": {"a": []}}
         result = to_msgpack(data)
 
-        decoded = from_msgpack(result)
+        decoded = cast(dict[str, Any], from_msgpack(result))
         assert decoded == data
 
     def test_to_msgpack_with_special_characters(self) -> None:
         """Test MessagePack with unicode and special characters."""
         data = {"unicode": "Hello 世界 🌍", "special": "line1\nline2\ttab"}
         result = to_msgpack(data)
 
-        decoded = from_msgpack(result)
+        decoded = cast(dict[str, Any], from_msgpack(result))
         assert decoded == data
 
     def test_msgpack_handles_encoding_error(self) -> None: