fastapi-startkit 0.56.0__tar.gz → 0.58.0__tar.gz

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fastapi-startkit
-Version: 0.56.0
+Version: 0.58.0
 Summary: A modular, provider-driven framework for building async Python web applications with FastAPI — bundling a service container, configuration system, an async-first ORM, facades, and a Cleo-powered console.
 Keywords: fastapi,framework,async,web,asgi,orm,sqlalchemy,pydantic,ioc-container,dependency-injection,service-provider,cli,console,configuration,microservices,starter-kit,boilerplate
 Author: Bedram Tamang

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-startkit"
-version = "0.56.0"
+version = "0.58.0"
 description = "A modular, provider-driven framework for building async Python web applications with FastAPI — bundling a service container, configuration system, an async-first ORM, facades, and a Cleo-powered console."
 readme = "README.md"
 keywords = [
@@ -107,7 +107,9 @@ dev = [
     "faker>=40.13.0",
     "langchain>=1.0.0",
     "langchain-core>=1.0.0",
+    "basedpyright>=1.31.4",
     "pyright>=1.1.411",
+    "pytest-benchmark>=5.2.3",
 ]
 
 
@@ -121,7 +123,7 @@ fixable = ["F401"]
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401"]
 
-[tool.pyright]
+[tool.basedpyright]
 include = ["src/fastapi_startkit"]
 exclude = [
     "**/tests",
@@ -137,6 +139,10 @@ pythonVersion = "3.12"
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 norecursedirs = [".venv", "dist", "build", "__pycache__"]
+markers = [
+    "benchmark: performance benchmark, excluded by default (run with -m benchmark)",
+]
+addopts = "-m 'not benchmark'"
 
 [tool.coverage.run]
 source = ["src/fastapi_startkit"]

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/ai/audio_factory.py

@@ -18,6 +18,9 @@ import asyncio
 import struct
 from abc import ABC, abstractmethod
 
+# Provider SDKs are optional extras imported lazily per backend, so they are
+# absent from the type-check environment; the pyright ignores below cover only that.
+
 
 class AudioFactory(ABC):
     """Abstract base for text-to-speech backends."""
@@ -53,7 +56,7 @@ class OpenAIAudioFactory(AudioFactory):
         speed: float,
         fmt: str,
     ) -> bytes:
-        from openai import AsyncOpenAI  # noqa: PLC0415
+        from openai import AsyncOpenAI  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
 
         client = AsyncOpenAI(api_key=self._api_key, base_url=self._base_url)
         response = await client.audio.speech.create(
@@ -126,8 +129,8 @@ class GoogleAudioFactory(AudioFactory):
             The ``speed`` parameter is accepted for API compatibility but is
             not currently supported by the Gemini TTS API.
         """
-        from google import genai  # noqa: PLC0415
-        from google.genai import types  # noqa: PLC0415
+        from google import genai  # noqa: PLC0415  # pyright: ignore[reportAttributeAccessIssue]
+        from google.genai import types  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
 
         client = genai.Client(api_key=self._api_key)
         google_voice = self._VOICE_MAP.get(voice, voice)
@@ -205,7 +208,7 @@ class ElevenLabsAudioFactory(AudioFactory):
         speed: float,
         fmt: str,
     ) -> bytes:
-        from elevenlabs.client import ElevenLabs  # noqa: PLC0415
+        from elevenlabs.client import ElevenLabs  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
 
         voice_id = self._VOICE_MAP.get(voice, voice)
         client = ElevenLabs(api_key=self._api_key)

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/ai/config/config.py

@@ -10,7 +10,7 @@ class AnthropicConfig:
     """Configuration for the Anthropic provider."""
 
     driver: str = "anthropic"
-    key: str = field(default_factory=lambda: env("ANTHROPIC_API_KEY", ""))
+    key: str = field(default_factory=lambda: env("ANTHROPIC_API_KEY", "", cast=False))
     url: str = field(default_factory=lambda: env("ANTHROPIC_BASE_URL", "https://api.anthropic.com"))
 
     models: dict = field(
@@ -25,7 +25,7 @@ class OpenAIConfig:
     """Configuration for the OpenAI provider."""
 
     driver: str = "openai"
-    key: str = field(default_factory=lambda: env("OPENAI_API_KEY", ""))
+    key: str = field(default_factory=lambda: env("OPENAI_API_KEY", "", cast=False))
     url: str = field(default_factory=lambda: env("OPENAI_BASE_URL", "https://api.openai.com/v1"))
 
     models: dict = field(
@@ -41,7 +41,9 @@ class GoogleConfig:
     """Configuration for the Google / Gemini provider."""
 
     driver: str = "google"
-    key: str = field(default_factory=lambda: env("GEMINI_API_KEY", "") or env("GOOGLE_API_KEY", ""))
+    key: str = field(
+        default_factory=lambda: env("GEMINI_API_KEY", "", cast=False) or env("GOOGLE_API_KEY", "", cast=False)
+    )
 
     models: dict = field(
         default_factory=lambda: {
@@ -56,7 +58,7 @@ class ElevenLabsConfig:
     """Configuration for the ElevenLabs provider."""
 
     driver: str = "elevenlabs"
-    key: str = field(default_factory=lambda: env("ELEVENLABS_API_KEY", ""))
+    key: str = field(default_factory=lambda: env("ELEVENLABS_API_KEY", "", cast=False))
 
     models: dict = field(
         default_factory=lambda: {

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/ai/image_factory.py

@@ -18,6 +18,9 @@ import asyncio
 import base64
 from abc import ABC, abstractmethod
 
+# Provider SDKs are optional extras imported lazily per backend, so they are
+# absent from the type-check environment; the pyright ignores below cover only that.
+
 
 class ImageFactory(ABC):
     """Abstract base for image generation backends."""
@@ -43,7 +46,7 @@ class OpenAIImageFactory(ImageFactory):
         self._base_url = base_url
 
     async def generate(self, prompt: str, size: str, model: str, quality: str) -> bytes:
-        from openai import AsyncOpenAI  # noqa: PLC0415
+        from openai import AsyncOpenAI  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
 
         client = AsyncOpenAI(api_key=self._api_key, base_url=self._base_url)
         params: dict = {
@@ -62,7 +65,7 @@ class OpenAIImageFactory(ImageFactory):
     async def edit(self, prompt: str, image_bytes: bytes, size: str) -> bytes:
         import io  # noqa: PLC0415
 
-        from openai import AsyncOpenAI  # noqa: PLC0415
+        from openai import AsyncOpenAI  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
 
         client = AsyncOpenAI(api_key=self._api_key, base_url=self._base_url)
         image_file = io.BytesIO(image_bytes)
@@ -118,8 +121,8 @@ class GoogleImageFactory(ImageFactory):
 
     async def generate(self, prompt: str, size: str, model: str, quality: str) -> bytes:
         """Generate an image via Imagen 3 and return raw PNG bytes."""
-        from google import genai  # noqa: PLC0415
-        from google.genai import types  # noqa: PLC0415
+        from google import genai  # noqa: PLC0415  # pyright: ignore[reportAttributeAccessIssue]
+        from google.genai import types  # noqa: PLC0415  # pyright: ignore[reportMissingImports]
 
         client = genai.Client(api_key=self._api_key)
         aspect_ratio = self._ASPECT_MAP.get(size, "1:1")

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/ai/pipeline.py

@@ -102,7 +102,7 @@ def build_pipeline(middlewares: list[Callable], core: Callable) -> Callable:
     for mw in reversed(middlewares):
         nxt = handler
         instance = mw() if isinstance(mw, type) else mw
-        call = instance.handle if hasattr(instance, "handle") else instance
+        call = instance.handle if isinstance(instance, Middleware) else instance
 
         def layer(model: Any, call: Callable = call, nxt: Callable = nxt) -> Response:
             async def _source() -> AsyncIterator:

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/ai/testing.py

@@ -142,27 +142,35 @@ class AgentFake:
         return False
 
     async def prompt(
-        self, message: str, *, attachments: list[Document] | None = None, config: dict | None = None
+        self,
+        message: str,
+        *,
+        model: str | None = None,
+        attachments: list[Document] | None = None,
+        provider_options: dict | None = None,
     ) -> dict:
         start = time.monotonic()
-        extra = {"config": config} if config is not None else {}
-        self._last_response = await self._agent.prompt(message, attachments=attachments, **extra)
+        self._last_response = await self._agent.prompt(
+            message, model=model, attachments=attachments, provider_options=provider_options
+        )
         self.last_elapsed = time.monotonic() - start
         self._remember(message, self._last_response)
         return self._last_response
 
-    async def stream(self, message: str, *, config: dict | None = None) -> AsyncIterator[dict]:
+    async def stream(
+        self, message: str, *, model: str | None = None, provider_options: dict | None = None
+    ) -> AsyncIterator[dict]:
         chunks: list[str] = []
-        extra = {"config": config} if config is not None else {}
         # Drive the runner directly so we can read the structured response it
         # captures while streaming (content + tool_calls), not just joined text.
         runner = self._agent.runner()
-        async for frame in runner.stream(message, **extra):
+        async for frame in runner.stream(message, model=model, provider_options=provider_options):
             if text := _frame_text(frame):
                 chunks.append(text)
             yield frame
-        self._last_response = getattr(runner, "last_response", None) or _text_state("".join(chunks))
-        self._remember(message, self._last_response)
+        state = getattr(runner, "last_response", None) or _text_state("".join(chunks))
+        self._last_response = state
+        self._remember(message, state)
 
     def _remember(self, message: str, state: dict) -> None:
         self._accumulate_tokens(state)
@@ -347,7 +355,7 @@ class AgentFake:
 
     async def _judge(
         self,
-        model: str,
+        model: str | None,
         expectation: str,
         content: str,
         provider: str | None = None,
@@ -356,7 +364,7 @@ class AgentFake:
     ) -> dict:
         return await self._judge_live(model, expectation, content, provider)
 
-    async def _judge_live(self, model: str, expectation: str, content: str, provider: str | None = None) -> dict:
+    async def _judge_live(self, model: str | None, expectation: str, content: str, provider: str | None = None) -> dict:
         from .judge import JudgeAgent  # noqa: PLC0415
 
         judge = JudgeAgent()
@@ -473,7 +481,12 @@ class AgentRecordFake(AgentFake):
         self._records.append(turn)
 
     async def prompt(
-        self, message: str, *, attachments: list[Document] | None = None, config: dict | None = None
+        self,
+        message: str,
+        *,
+        model: str | None = None,
+        attachments: list[Document] | None = None,
+        provider_options: dict | None = None,
     ) -> dict:
         cassette, store = self._load()
         key = self._key(message, attachments)
@@ -481,8 +494,9 @@ class AgentRecordFake(AgentFake):
         if key in store:
             state = self._state_from_cache(store[key])
         else:
-            extra = {"config": config} if config is not None else {}
-            state = await self._real.prompt(message, attachments=attachments, **extra)
+            state = await self._real.prompt(
+                message, model=model, attachments=attachments, provider_options=provider_options
+            )
             self._save(cassette, store, key, self._turn(message, state))
         state = self._real.runner()._apply_schema(state)
         self.last_elapsed = time.monotonic() - start
@@ -490,7 +504,9 @@ class AgentRecordFake(AgentFake):
         self._remember_turn(message, state)
         return state
 
-    async def stream(self, message: str, *, config: dict | None = None) -> AsyncIterator[dict]:
+    async def stream(
+        self, message: str, *, model: str | None = None, provider_options: dict | None = None
+    ) -> AsyncIterator[dict]:
         cassette, store = self._load()
         key = self._key(message, None)
         if key in store:
@@ -507,12 +523,11 @@ class AgentRecordFake(AgentFake):
             for chunk in chunks:
                 yield _chunk_event(chunk)
         else:
-            extra = {"config": config} if config is not None else {}
             # Drive the runner directly to capture the structured state
             # (messages + chunks) it records while streaming.
             runner = self._real.runner()
             chunks = []
-            async for frame in runner.stream(message, **extra):
+            async for frame in runner.stream(message, model=model, provider_options=provider_options):
                 if text := _frame_text(frame):
                     chunks.append(text)
                 yield frame
@@ -534,7 +549,7 @@ class AgentRecordFake(AgentFake):
 
     async def _judge(
         self,
-        model: str,
+        model: str | None,
         expectation: str,
         content: str,
         provider: str | None = None,
@@ -554,7 +569,7 @@ class AgentRecordFake(AgentFake):
         return verdict
 
     @staticmethod
-    def _judge_key(model: str, expectation: str, content: str, provider: str | None = None) -> str:
+    def _judge_key(model: str | None, expectation: str, content: str, provider: str | None = None) -> str:
         payload = json.dumps(
             {"judge_model": model, "judge_provider": provider, "expectation": expectation, "content": content},
             sort_keys=True,

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/application.py

@@ -34,8 +34,8 @@ class Application(Container, Generic[TConfig]):
 
     def __init__(
         self,
-        base_path: str | Path = None,
-        env=None,
+        base_path: str | Path | None = None,
+        env: str | None = None,
         providers=None,
         config: Type[TConfig] | None = None,
         exception_handler: Type[ExceptionHandler] | None = None,
@@ -43,7 +43,7 @@ class Application(Container, Generic[TConfig]):
         super().__init__()
 
         self.base_path: Path = Path(base_path) if base_path else Path(os.getcwd())
-        self.env = env
+        self.env: str | None = env
         self.providers = self.DEFAULT_PROVIDERS + (providers or [])
         self.published_resources = {}
         self.commands = []
@@ -72,12 +72,14 @@ class Application(Container, Generic[TConfig]):
 
     def load_environment(self):
         """Reload environment variables for the current self.env."""
+        # resolve_environment() runs during __init__, so env is always set here.
+        assert self.env is not None
         Environment.load_base(base_path=self.base_path)
         Environment.load(self.env, base_path=self.base_path)
         return self
 
     def configure_exception_handler(self):
-        self.exception_manager: ExceptionHandler = self._exception_handler_class(application=self)
+        self.exception_manager = self._exception_handler_class(application=self)
         self.exception_manager.register()
         self.exception_manager.install()
         self.bind("exception_manager", self.exception_manager)
@@ -138,10 +140,10 @@ class Application(Container, Generic[TConfig]):
         return self.fastapi.options(path, **kwargs)
 
     def head(self, path: str, **kwargs) -> Callable:
-        return self._fastapi.head(path, **kwargs)
+        return self.fastapi.head(path, **kwargs)
 
     def trace(self, path: str, **kwargs) -> Callable:
-        return self._fastapi.trace(path, **kwargs)
+        return self.fastapi.trace(path, **kwargs)
 
     # Include routers
     def include_router(self, router: "APIRouter", **kwargs):
@@ -150,7 +152,7 @@ class Application(Container, Generic[TConfig]):
 
     # Add middleware
     def add_middleware(self, middleware_class: Type["BaseHTTPMiddleware"], **options):
-        self._fastapi.add_middleware(middleware_class, **options)
+        self.fastapi.add_middleware(middleware_class, **options)
         return self
 
     # Add event handlers (startup/shutdown)
@@ -160,12 +162,12 @@ class Application(Container, Generic[TConfig]):
 
     # Mount sub-apps
     def mount(self, path: str, app_instance: "FastAPI", **kwargs):
-        self._fastapi.mount(path, app_instance, **kwargs)
+        self.fastapi.mount(path, app_instance, **kwargs)
         return self
 
     # Add custom exception handlers
     def add_exception_handler(self, exc_class_or_status_code: Any, handler: Callable[..., Any]):
-        self._fastapi.add_exception_handler(exc_class_or_status_code, handler)
+        self.fastapi.add_exception_handler(exc_class_or_status_code, handler)
         return self
 
     @property
@@ -210,12 +212,12 @@ class Application(Container, Generic[TConfig]):
     def configure_paths(self):
         self.bind("config.location", self.base_path / "config")
 
-    def use_config_path(self, path: str = None):
+    def use_config_path(self, path: str | None = None):
         self.bind("config.location", path)
 
         return self
 
-    def use_storage_path(self, path: str = None):
+    def use_storage_path(self, path: str | None = None):
         self.bind("storage.location", path)
 
         return self

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/broadcasting/provider.py

@@ -143,6 +143,9 @@ class ReverbProvider(Provider):
                 form = await request.form()
                 channel_name = form.get("channel_name", "")
 
+            if not isinstance(channel_name, str):
+                return JSONResponse({"error": "channel_name must be a string"}, status_code=422)
+
             # Resolve authenticated user.
             # Prefer request.state.user (set by auth middleware), then fall
             # back to the container's "auth" service.

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/configuration/Configuration.py

@@ -1,3 +1,6 @@
+from collections.abc import Mapping
+from typing import Any, cast
+
 from fastapi_startkit.loader import Loader
 from ..support.structures import data
 from ..exceptions import InvalidConfigurationSetup
@@ -47,7 +50,8 @@ class Configuration:
         else:
             params = external_config
         base_config = {name.lower(): value for name, value in params.items()}
-        merged_config = {**base_config, **self.get(path, {})}
+        project_config = cast("Mapping[str, Any]", self._config.get(path, {}))
+        merged_config = {**base_config, **project_config}
         self.set(path, merged_config)
 
     def set(self, path, value):

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/console/can_override_default_options.py

@@ -1,7 +1,8 @@
+from cleo.commands.command import Command
 from inflection import underscore
 
 
-class CanOverrideOptionsDefault:
+class CanOverrideOptionsDefault(Command):
     """Command mixin to allow to override optional argument default values when instantiating the
     command.
     Example: SomeCommand(app, option1="other/default").

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/console/publish_command.py

@@ -1,6 +1,6 @@
 import os
 import shutil
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 from fastapi_startkit.console import Command
 from cleo.helpers import option
@@ -23,14 +23,14 @@ class PublishCommand(Command):
         ),
     ]
 
-    def handle(self):
+    def handle(self) -> int:
         from fastapi_startkit.application import app
 
-        application: "Application" = app()
+        application = cast("Application", app())
 
         if not application.published_resources:
             self.line("<comment>Nothing to publish.</comment>")
-            return
+            return 0
 
         provider_arg = self.option("provider")
 
@@ -41,7 +41,7 @@ class PublishCommand(Command):
             }
             if not resources:
                 self.line(f"<error>No provider found matching '{provider_arg}'.</error>")
-                return
+                return 0
         else:
             resources = application.published_resources
 
@@ -61,3 +61,5 @@ class PublishCommand(Command):
                 os.makedirs(os.path.dirname(dest_path), exist_ok=True)
                 shutil.copy2(source, dest_path)
                 self.line(f"  [{provider_key}] Published <info>{destination}</info>")
+
+        return 0

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/container/container.py

@@ -1,7 +1,7 @@
 """Core of the IOC Container."""
 
 import inspect
-from typing import Any
+from typing import Any, ClassVar, TypeVar, overload
 
 from ..exceptions import (
     ContainerError,
@@ -9,6 +9,8 @@ from ..exceptions import (
     StrictContainerException,
 )
 
+T = TypeVar("T")
+
 
 class Container:
     """Core of the Service Container.
@@ -16,14 +18,14 @@ class Container:
     Performs bindings and resolving of objects to and from the container.
     """
 
-    _instance = None
+    _instance: ClassVar["Container | None"] = None
 
     @classmethod
-    def set_instance(cls, instance):
+    def set_instance(cls, instance: "Container") -> None:
         cls._instance = instance
 
     @classmethod
-    def instance(cls):
+    def instance(cls) -> "Container":
         if cls._instance is None:
             raise RuntimeError("Container not initialized")
         return cls._instance
@@ -103,11 +105,22 @@ class Container:
         obj = self.resolve(class_obj)
         self.bind(name, obj)
 
-    def make(self, name, *arguments):
+    @overload
+    def make(self, name: type[T], *arguments: Any) -> T: ...
+
+    @overload
+    def make(self, name: str, *arguments: Any) -> Any: ...
+
+    def make(self, name: type[T] | str, *arguments: Any) -> Any:
         """Retrieve a class from the container by key.
 
+        A class key resolves to an instance of that class, so `make(Foo)` is
+        typed as `Foo`. A string key carries no static type information, so it
+        stays `Any` and callers annotate the binding themselves. The return is
+        never `None`: a missing key raises instead.
+
         Arguments:
-            name {string} -- Key in the container that you want to get.
+            name {string | type} -- Key in the container that you want to get.
 
         Raises:
             MissingContainerBindingNotFound -- Raised if the key is not in the container.

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/environment/environment.py

@@ -2,6 +2,7 @@
 
 import os
 import sys
+from pathlib import Path
 from typing import Any, Literal, TypeVar, overload
 
 from dotenv import load_dotenv
@@ -13,7 +14,7 @@ EnvValue = str | int | bool
 
 class Environment:
     @staticmethod
-    def resolve_environment(base_path=None, env: str | None = None):
+    def resolve_environment(base_path: Path | None = None, env: str | None = None):
         Environment.resolve_environment_from_argument()
 
         if "PYTEST_CURRENT_TEST" in os.environ:
@@ -26,7 +27,7 @@ class Environment:
         if os.environ.get("APP_ENV"):
             return os.environ["APP_ENV"]
 
-        path = base_path / ".env"
+        path = Environment._require_base_path(base_path) / ".env"
         if not path.exists():
             raise ValueError("Unable to determine environment.")
 
@@ -39,15 +40,22 @@ class Environment:
         return env
 
     @staticmethod
-    def load_base(base_path=None):
+    def _require_base_path(base_path: Path | None) -> Path:
+        # Keeps the TypeError the old unguarded `None / ".env"` raised, with a clearer message.
+        if base_path is None:
+            raise TypeError("base_path is required to locate .env files")
+        return base_path
+
+    @staticmethod
+    def load_base(base_path: Path | None = None):
         """Load the base .env file, resetting vars to their default values."""
-        path = base_path / ".env"
+        path = Environment._require_base_path(base_path) / ".env"
         if path.exists():
             load_dotenv(path, override=True)
 
     @staticmethod
-    def load(env: str, override=True, only=None, base_path=None):
-        path = base_path / f".env.{env}"
+    def load(env: str, override=True, only=None, base_path: Path | None = None):
+        path = Environment._require_base_path(base_path) / f".env.{env}"
         if not path.exists():
             return
         load_dotenv(path, override=override)

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/events/dispatcher.py

@@ -7,13 +7,17 @@ coroutine listeners are supported — coroutine results are awaited transparentl
 
 import inspect
 from fnmatch import fnmatchcase
-from typing import TYPE_CHECKING, Any, Callable, cast, overload
+from typing import TYPE_CHECKING, Any, Callable, Protocol, cast, overload
 
 if TYPE_CHECKING:
     from ..container import Container
     from .fake import EventFake
 
 
+class _ClassListener(Protocol):
+    def handle(self, *args: Any) -> Any: ...
+
+
 class Dispatcher:
     def __init__(self, container: "Container | None" = None):
         self._container = container
@@ -132,7 +136,7 @@ class Dispatcher:
 
     def _resolve_listener(self, listener: Callable) -> Callable:
         if inspect.isclass(listener):
-            return self._make(listener).handle
+            return cast(_ClassListener, self._make(listener)).handle
         return listener
 
     def _make(self, cls):

{fastapi_startkit-0.56.0 → fastapi_startkit-0.58.0}/src/fastapi_startkit/facades/Dump.pyi

@@ -1,26 +1,31 @@
-from typing import Any, List, TYPE_CHECKING
+from typing import Any, List
 
-if TYPE_CHECKING:
-    from ..dumps import Dump as DumpObject
+DumpObject = Any
 
 class Dump:
     """Dumper facade."""
 
-    def clear(self) -> "Dump":
+    @staticmethod
+    def clear() -> "Dump":
         """Clear all dumped data"""
         ...
-    def dd(*objects: List[Any]):
+    @staticmethod
+    def dd(*objects: Any):
         """Dump all provided args and die, raising a DumpException."""
         ...
-    def dump(*objects: List[Any]):
+    @staticmethod
+    def dump(*objects: Any):
         """Dump all provided args and continue code execution. This does not raise a DumpException."""
         ...
+    @staticmethod
     def get_dumps(ascending: bool = False) -> List[DumpObject]:
         """Get all dumps as Dump objects. If ascending is True, get dumps from oldest to most recents."""
         ...
-    def last(self) -> DumpObject:
+    @staticmethod
+    def last() -> DumpObject:
         """Return last added dump."""
         ...
+    @staticmethod
     def get_serialized_dumps(ascending: bool = False) -> List[dict]:
         """Get all dumps as dict. If ascending is True, sort dumps from oldest to most recents."""
         ...