Add mypy to pre-commit

Add ruff rules

Author: yugokato

.pre-commit-config.yaml

@@ -26,3 +26,8 @@ repos:
       entry: ruff format
       language: system
       types: [ python ]
+    - id: mypy
+      name: mypy
+      entry: mypy src
+      pass_filenames: false
+      language: system

pyproject.toml

@@ -30,7 +30,7 @@ dependencies = [
     "pydantic-extra-types==2.9.0",
     "pydantic[email]==2.9.2",
     "PyYAML==6.0.1",
-    "ruff==0.9.5"
+    "ruff==0.11.0"
 ]
 dynamic = ["version"]
 
@@ -75,6 +75,7 @@ select = [
     "PLE",  # Pylint error
     "PLW",  # Pylint warning
     "RUF",  # Ruff-specific rules
+    "T20",  # flake8-print
     "UP",   # pyupgrade
     "W",    # pycodestyle warning
 ]
@@ -93,3 +94,31 @@ ignore = [
 [tool.ruff.format]
 docstring-code-format = true
 docstring-code-line-length = "dynamic"
+
+[tool.mypy]
+plugins = ["pydantic.mypy"]
+files = [
+    "src"
+]
+mypy_path = [
+    "src"
+]
+follow_imports = "skip"
+check_untyped_defs = true
+disallow_any_generics = true
+disallow_untyped_defs = true
+follow_untyped_imports = false
+ignore_missing_imports = true
+strict_equality = true
+warn_redundant_casts = true
+warn_unreachable = true
+warn_unused_ignores = true
+disable_error_code = [
+    "import-untyped",
+    "misc",
+    "operator",
+    "override",
+    "return",
+    "type-arg",
+    "union-attr"
+]

src/demo_app/__init__.py

@@ -27,7 +27,7 @@ def create_app(version: int = 1) -> Quart:
     return app
 
 
-def _register_blueprints(app, version: int):
+def _register_blueprints(app: Quart, version: int) -> None:
     from demo_app.api.auth.auth import bp_auth
     from demo_app.api.user.user import bp_user
     from demo_app.handlers.error_handlers import bp_error_handler

src/demo_app/api/user/models.py

@@ -30,7 +30,7 @@ class SocialLinks(BaseModel):
 
 
 class Preferences(BaseModel):
-    theme: UserTheme | None = UserTheme.LIGHT_MODE.value
+    theme: UserTheme | None = UserTheme.LIGHT_MODE
     language: str | None = None
     font_size: int | None = Field(None, ge=8, le=40, multiple_of=2)
 

src/demo_app/handlers/error_handlers.py

@@ -1,29 +1,30 @@
 import json
 from dataclasses import dataclass
+from typing import Any
 
 from quart import Blueprint, Response, jsonify, make_response, request
 from quart import current_app as app
 from quart_schema import RequestSchemaValidationError
-from werkzeug.exceptions import NotFound
+from werkzeug.exceptions import BadRequest, NotFound, Unauthorized
 
 bp_error_handler = Blueprint("error_handler", __name__)
 
 
 @dataclass
 class Error:
     code: int
-    message: str
+    message: Any
     request_id: str
 
 
 @bp_error_handler.app_errorhandler(400)
-async def handle_bad_request_error(error) -> Response:
+async def handle_bad_request_error(error: BadRequest) -> Response:
     err = Error(code=400, message=str(error), request_id=request.headers["X-Request-ID"])
     return await make_response(jsonify({"error": err}), 400)
 
 
 @bp_error_handler.app_errorhandler(401)
-async def handle_unauthorized_request(error) -> Response:
+async def handle_unauthorized_request(error: Unauthorized) -> Response:
     err = Error(code=401, message="Login required", request_id=request.headers["X-Request-ID"])
     return await make_response(jsonify({"error": err}), 401)
 

src/demo_app/handlers/request_handlers.py

@@ -6,7 +6,7 @@
 
 
 @bp_request_handler.before_app_request
-async def before_request():
+async def before_request() -> None:
     if not request.headers.get("X-Request-ID"):
         request.headers["X-Request-ID"] = str(uuid.uuid4())
 

src/demo_app/main.py

@@ -5,7 +5,7 @@
 DEFAULT_PORT = 5000
 
 
-def parse_pargs():
+def parse_pargs() -> argparse.Namespace:
     parser = argparse.ArgumentParser()
     parser.add_argument("-p", "--port", dest="port", type=int, default=DEFAULT_PORT)
     return parser.parse_args()

src/openapi_test_client/__init__.py

@@ -28,7 +28,7 @@ def is_external_project() -> bool:
     return bool(os.environ.get(ENV_VAR_PACKAGE_DIR, "") or not Path.cwd().is_relative_to(_PROJECT_ROOT_DIR))
 
 
-def find_external_package_dir(current_dir: Path | None = None, missing_ok: bool = False) -> Path:
+def find_external_package_dir(current_dir: Path | None = None, missing_ok: bool = False) -> Path | None:
     """Find an external package directory
 
     An external directory should have .api_test_client hidden file
@@ -45,17 +45,17 @@ def find_external_package_dir(current_dir: Path | None = None, missing_ok: bool
             f"Please create a project directory and start from there"
         )
 
-    def search_parent_dirs(dir: Path):
+    def search_parent_dirs(dir: Path) -> Path | None:
         if (dir / filename).exists():
             return dir
 
         parent = dir.parent
         if parent == dir:
-            return
+            return None
 
         return search_parent_dirs(parent)
 
-    def search_child_dirs(dir: Path):
+    def search_child_dirs(dir: Path) -> Path | None:
         if hidden_files := glob.glob(f"**/{filename}", root_dir=dir, recursive=True):
             module_paths = [(dir / x).parent for x in hidden_files]
             if len(module_paths) > 1:
@@ -82,7 +82,7 @@ def get_package_dir() -> Path:
             return Path(api_client_package_dir).resolve()
         else:
             try:
-                return find_external_package_dir()
+                return find_external_package_dir() or _PACKAGE_DIR
             except FileNotFoundError:
                 # Initial script run from an external location. The directory hasn't been setup yet
                 return _PACKAGE_DIR

src/openapi_test_client/clients/__init__.py

@@ -1,6 +1 @@
-from typing import TYPE_CHECKING, TypeVar
-
-from openapi_test_client.clients.base import OpenAPIClient
-
-if TYPE_CHECKING:
-    APIClientType = TypeVar("APIClientType", bound=OpenAPIClient)
+from .base import OpenAPIClient

src/openapi_test_client/clients/base.py

@@ -3,7 +3,7 @@
 import importlib
 import inspect
 import json
-from typing import TYPE_CHECKING
+from typing import Any, TypeVar
 
 from common_libs.clients.rest_client import RestClient
 from common_libs.logging import get_logger
@@ -12,12 +12,10 @@
 from openapi_test_client.libraries.api.api_spec import OpenAPISpec
 from openapi_test_client.libraries.common.misc import get_module_name_by_file_path
 
-if TYPE_CHECKING:
-    from openapi_test_client.clients import APIClientType
-
-
 logger = get_logger(__name__)
 
+T = TypeVar("T", bound="OpenAPIClient")
+
 
 class OpenAPIClient:
     """Base class for all clients"""
@@ -50,11 +48,11 @@ def base_url(self) -> str:
         return self._base_url
 
     @base_url.setter
-    def base_url(self, url: str):
+    def base_url(self, url: str) -> None:
         self._base_url = url
 
-    @staticmethod
-    def get_client(app_name: str, **init_options) -> APIClientType:
+    @classmethod
+    def get_client(cls: type[T], app_name: str, **init_options: Any) -> T:
         """Get API client for the app
 
         :param app_name: App name
@@ -68,13 +66,13 @@ def get_client(app_name: str, **init_options) -> APIClientType:
 
         client_module_name = get_module_name_by_file_path(client_file)
         mod = importlib.import_module(client_module_name)
-        clients = [
+        client_classes: list[type[T]] = [
             x
             for x in mod.__dict__.values()
             if inspect.isclass(x) and issubclass(x, OpenAPIClient) and x is not OpenAPIClient
         ]
-        if len(clients) != 1:
+        if len(client_classes) != 1:
             raise RuntimeError(f"Unable to locate the API client for {app_name} from {mod}")
 
-        api_client: type[APIClientType] = clients[0]
-        return api_client(**init_options)
+        APIClientClass = client_classes[0]
+        return APIClientClass(**init_options)

src/openapi_test_client/clients/demo_app/api/__init__.py

@@ -2,4 +2,4 @@
 
 from .base import DemoAppBaseAPI
 
-API_CLASSES = init_api_classes(DemoAppBaseAPI)
+API_CLASSES = init_api_classes(DemoAppBaseAPI)  # type: ignore[type-abstract]

src/openapi_test_client/clients/demo_app/api/base/demo_app_api.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from common_libs.clients.rest_client import RestResponse
 from requests.exceptions import RequestException
@@ -24,9 +24,9 @@ def post_request_hook(
         endpoint: Endpoint,
         response: RestResponse | None,
         request_exception: RequestException | None,
-        *path_params,
-        **params,
-    ):
+        *path_params: Any,
+        **params: Any,
+    ) -> None:
         super().post_request_hook(endpoint, response, request_exception, *path_params, **params)
         if response and response.ok:
             if endpoint in self.api_client.Auth.endpoints:

src/openapi_test_client/clients/demo_app/api/request_hooks/post_request.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from common_libs.clients.rest_client import RestResponse
@@ -10,8 +10,8 @@
 
 
 def do_something_after_request(
-    api_client: DemoAppAPIClient, endpoint: Endpoint, r: RestResponse, *path_params, **params
-):
+    api_client: DemoAppAPIClient, endpoint: Endpoint, r: RestResponse, *path_params: Any, **params: Any
+) -> None:
     """This is a template of the post-request hook that will be called right after making a request
 
     To enable this hook, call this function inside the base API class's post_request_hook():
@@ -31,10 +31,10 @@ def do_something_after_request(
     >>>     do_something_after_request(self.api_client, endpoint, response, *path_params, *params)
     """
     # Do something after request
-    pass
+    ...
 
 
-def manage_auth_session(api_client: DemoAppAPIClient, endpoint: Endpoint, r: RestResponse):
+def manage_auth_session(api_client: DemoAppAPIClient, endpoint: Endpoint, r: RestResponse) -> None:
     """Manage auth after successful login/logout
 
     :param api_client: API client

src/openapi_test_client/clients/demo_app/api/request_hooks/pre_request.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from openapi_test_client.clients.demo_app import DemoAppAPIClient
     from openapi_test_client.libraries.api import Endpoint
 
 
-def do_something_before_request(api_client: DemoAppAPIClient, endpoint: Endpoint, **params):
+def do_something_before_request(api_client: DemoAppAPIClient, endpoint: Endpoint, **params: Any) -> None:
     """This is a template of the pre-request hook that will be called right before making a request
 
     To enable this hook, call this function inside the base API class's pre_request_hook():
@@ -17,4 +17,4 @@ def do_something_before_request(api_client: DemoAppAPIClient, endpoint: Endpoint
     >>>     do_something_before_request(self.api_client, endpoint, *params)
     """
     # Do something before request
-    pass
+    ...

src/openapi_test_client/clients/demo_app/api/request_hooks/request_wrapper.py

@@ -2,14 +2,10 @@
 
 from collections.abc import Callable
 from functools import wraps
-from typing import TYPE_CHECKING, ParamSpec
+from typing import ParamSpec
 
 from common_libs.clients.rest_client import RestResponse
 
-if TYPE_CHECKING:
-    from openapi_test_client.libraries.api import EndpointFunc
-
-
 P = ParamSpec("P")
 
 
@@ -30,9 +26,9 @@ def do_something_before_and_after_request(f: Callable[P, RestResponse]) -> Calla
     """
 
     @wraps(f)
-    def wrapper(endpoint_func: EndpointFunc, *args: P.args, **kwargs: P.kwargs) -> RestResponse:
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> RestResponse:
         # Do something before request
-        r = f(endpoint_func, *args, **kwargs)
+        r = f(*args, **kwargs)
         # Do something after request
         return r
 

src/openapi_test_client/libraries/api/api_classes/__init__.py

@@ -3,17 +3,13 @@
 import inspect
 import itertools
 from pathlib import Path
-from typing import TYPE_CHECKING, TypeVar
 
 from openapi_test_client.libraries.common.misc import import_module_from_file_path
 
 from .base import APIBase
 
-if TYPE_CHECKING:
-    APIClassType = TypeVar("APIClassType", bound=APIBase)
 
-
-def init_api_classes(base_api_class: type[APIClassType]) -> list[type[APIClassType]]:
+def init_api_classes(base_api_class: type[APIBase]) -> list[type[APIBase]]:
     """Initialize API classes and return a list of API classes.
 
     - A list of Endpoint objects for an API class is available via its `endpoints` attribute
@@ -37,6 +33,7 @@ def init_api_classes(base_api_class: type[APIClassType]) -> list[type[APIClassTy
     from openapi_test_client.libraries.api.api_functions import EndpointFunc, EndpointHandler
 
     previous_frame = inspect.currentframe().f_back
+    assert previous_frame
     caller_file_path = inspect.getframeinfo(previous_frame).filename
     assert caller_file_path.endswith("__init__.py"), (
         f"API classes must be initialized in __init__.py. Unexpectedly called from {caller_file_path}"
@@ -50,7 +47,7 @@ def init_api_classes(base_api_class: type[APIClassType]) -> list[type[APIClassTy
         api_class.endpoints = []
         for attr_name, attr in api_class.__dict__.items():
             if isinstance(attr, EndpointHandler):
-                endpoint_func = getattr(api_class, attr_name)
+                endpoint_func: EndpointFunc = getattr(api_class, attr_name)
                 assert isinstance(endpoint_func, EndpointFunc)
                 api_class.endpoints.append(endpoint_func.endpoint)
 
@@ -59,10 +56,10 @@ def init_api_classes(base_api_class: type[APIClassType]) -> list[type[APIClassTy
         itertools.chain(*(x.endpoints for x in api_classes if x.endpoints)),
         key=lambda x: (x.tags, x.method, x.path),
     )
-    return sorted(api_classes, key=lambda x: x.TAGs)
+    return sorted(api_classes, key=lambda x: x.TAGs)  # type: ignore[arg-type, return-value]
 
 
-def get_api_classes(api_class_dir: Path, base_api_class: type[APIClassType]) -> list[type[APIClassType]]:
+def get_api_classes(api_class_dir: Path, base_api_class: type[APIBase]) -> list[type[APIBase]]:
     """Get all API classes defined under the given API class directory"""
     assert api_class_dir.is_dir()