fastapi-factory-utilities 0.2.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

fastapi_factory_utilities/core/plugins/taskiq_plugins/schedulers.py

@@ -0,0 +1,187 @@
+"""Scheduler module for fastapi_factory_utilities.
+
+This module provides components and utilities for scheduling tasks using Taskiq, FastAPI, and Redis.
+It enables registration, configuration, and management of scheduled tasks in FastAPI applications.
+"""
+
+import asyncio
+from collections.abc import Coroutine
+from typing import Any, Self, cast
+
+import taskiq_fastapi
+from fastapi import FastAPI
+from structlog.stdlib import get_logger
+from taskiq import (
+    AsyncBroker,
+    AsyncTaskiqDecoratedTask,
+    ScheduleSource,
+    TaskiqScheduler,
+)
+from taskiq.api import run_receiver_task, run_scheduler_task
+from taskiq.scheduler.created_schedule import CreatedSchedule
+from taskiq.scheduler.scheduled_task import ScheduledTask
+from taskiq_redis import (
+    ListRedisScheduleSource,
+    RedisAsyncResultBackend,
+    RedisStreamBroker,
+)
+
+_logger = get_logger(__package__)
+
+
+class SchedulerComponent:
+    """Scheduler component."""
+
+    NAME_SUFFIX: str = "tiktok_integration"
+
+    def __init__(self) -> None:
+        """Initialize the scheduler component."""
+        self._result_backend: RedisAsyncResultBackend[Any] | None = None
+        self._stream_broker: RedisStreamBroker | None = None
+        self._scheduler: TaskiqScheduler | None = None
+        self._scheduler_source: ListRedisScheduleSource | None = None
+        self._dyn_task: AsyncTaskiqDecoratedTask[Any, Any] | None = None
+        self._schedule_cron: ScheduledTask | None = None
+        self._schedulers_tasks: dict[str, AsyncTaskiqDecoratedTask[Any, Any]] = {}
+
+    def register_task(self, task: Coroutine[Any, Any, Any], task_name: str) -> None:
+        """Register a task.
+
+        Args:
+            task: The task to register.
+            task_name: The name of the task.
+
+        Raises:
+            ValueError: If the task is already registered.
+            ValueError: If the stream broker is not initialized.
+        """
+        if self._stream_broker is None:
+            raise ValueError("Stream broker is not initialized")
+
+        if task_name in self._schedulers_tasks:
+            raise ValueError(f"Task {task_name} already registered")
+
+        self._schedulers_tasks[task_name] = self._stream_broker.register_task(task, task_name)  # type: ignore
+
+    def get_task(self, task_name: str) -> AsyncTaskiqDecoratedTask[Any, Any]:
+        """Get a task.
+
+        Args:
+            task_name: The name of the task.
+
+        Returns:
+            AsyncTaskiqDecoratedTask: The task.
+
+        Raises:
+            ValueError: If the task is not registered.
+        """
+        if task_name not in self._schedulers_tasks:
+            raise ValueError(f"Task {task_name} not registered")
+        return self._schedulers_tasks[task_name]
+
+    def configure(self, redis_connection_string: str, app: FastAPI) -> Self:
+        """Configure the scheduler component."""
+        self._result_backend = RedisAsyncResultBackend(
+            redis_url=redis_connection_string,
+            prefix_str=f"velmios_taskiq_result_backend_{self.NAME_SUFFIX}",
+            result_ex_time=120,
+        )
+        self._stream_broker = RedisStreamBroker(
+            url=redis_connection_string,
+            queue_name=f"velmios_taskiq_stream_broker_{self.NAME_SUFFIX}",
+            consumer_group_name=f"velmios_taskiq_consumer_group_{self.NAME_SUFFIX}",
+        ).with_result_backend(self._result_backend)
+
+        taskiq_fastapi.populate_dependency_context(self._stream_broker, app)
+
+        self._scheduler_source = ListRedisScheduleSource(
+            url=redis_connection_string,
+            prefix=f"velmios_taskiq_schedule_source_{self.NAME_SUFFIX}",
+        )
+
+        self._scheduler = TaskiqScheduler(
+            broker=self._stream_broker,
+            sources=[self._scheduler_source],
+        )
+
+        return self
+
+    async def startup(self, app: FastAPI) -> None:
+        """Start the scheduler."""
+        if self._result_backend is None:
+            raise ValueError("Result backend is not initialized")
+        if self._stream_broker is None:
+            raise ValueError("Stream broker is not initialized")
+        if self._scheduler is None:
+            raise ValueError("Scheduler is not initialized")
+        if self._scheduler_source is None:
+            raise ValueError("Scheduler source is not initialized")
+
+        _logger.info("Starting scheduler")
+        await self._result_backend.startup()
+        await self._stream_broker.startup()
+        await self._scheduler.startup()
+        _logger.info("Scheduler started")
+        _logger.info("Scheduling task")
+        schedules: list[ScheduledTask] = await self._scheduler_source.get_schedules()
+        _logger.info("Schedules retrieved", schedules=schedules)
+
+        self._schedule_cron = next(filter(lambda x: x.task_name == "heartbeat", schedules), None)
+
+        if self._schedule_cron is None:
+            _logger.info("No schedules found, scheduling task")
+            self._dyn_task = self.get_task("heartbeat")
+            task_created: CreatedSchedule[Any] = await self._dyn_task.schedule_by_cron(
+                source=self._scheduler_source, cron="* * * * *", msg="every minute"
+            )
+            self._schedule_cron = task_created.task
+            _logger.info("Task scheduled")
+        else:
+            _logger.info("Schedules found, skipping scheduling")
+
+        _logger.info("Starting worker and scheduler tasks")
+        taskiq_fastapi.populate_dependency_context(self._stream_broker, app, app.state)  # type: ignore
+        self._worker_task: asyncio.Task[None] = asyncio.create_task(run_receiver_task(self._stream_broker))
+        self._scheduler_task: asyncio.Task[None] = asyncio.create_task(run_scheduler_task(self._scheduler))
+        _logger.info("Worker and scheduler tasks started")
+
+    async def shutdown(self) -> None:
+        """Stop the scheduler."""
+        _logger.info("Stopping worker")
+        self._worker_task.cancel()
+        self._scheduler_task.cancel()
+        try:
+            await self._worker_task
+        except (asyncio.CancelledError, RuntimeError) as e:
+            _logger.info("Worker task cancelled", error=e)
+        try:
+            await self._scheduler_task
+        except (asyncio.CancelledError, RuntimeError) as e:
+            _logger.info("Scheduler task cancelled", error=e)
+
+        while not self._worker_task.done() or not self._scheduler_task.done():
+            await asyncio.sleep(0.1)
+
+        _logger.info("Stopping scheduler")
+        if self._scheduler is not None:
+            await self._scheduler.shutdown()
+        if self._stream_broker is not None:
+            await self._stream_broker.shutdown()
+        if self._result_backend is not None:
+            await self._result_backend.shutdown()
+        _logger.info("Scheduler stopped")
+
+    @property
+    def scheduler(self) -> TaskiqScheduler:
+        """Get the scheduler."""
+        return cast(TaskiqScheduler, self._scheduler)
+
+    @property
+    def broker(self) -> AsyncBroker:
+        """Get the broker."""
+        return cast(AsyncBroker, self._stream_broker)
+
+    @property
+    def scheduler_source(self) -> ScheduleSource:
+        """Get the scheduler source."""
+        return cast(ScheduleSource, self._scheduler_source)

fastapi_factory_utilities/core/protocols.py

@@ -1,17 +1,15 @@
 """Protocols for the base application."""
 
 from abc import abstractmethod
-from typing import TYPE_CHECKING, ClassVar, Protocol, runtime_checkable
+from typing import TYPE_CHECKING, ClassVar, Protocol
 
 from beanie import Document
 from fastapi import FastAPI
 
-from fastapi_factory_utilities.core.plugins import PluginsEnum
 from fastapi_factory_utilities.core.services.status.services import StatusService
 
 if TYPE_CHECKING:
     from fastapi_factory_utilities.core.app.config import RootConfig
-    from fastapi_factory_utilities.core.plugins import PluginState
 
 
 class ApplicationAbstractProtocol(Protocol):
@@ -21,8 +19,6 @@ class ApplicationAbstractProtocol(Protocol):
 
     ODM_DOCUMENT_MODELS: ClassVar[list[type[Document]]]
 
-    DEFAULT_PLUGINS_ACTIVATED: ClassVar[list[PluginsEnum]]
-
     @abstractmethod
     def get_config(self) -> "RootConfig":
         """Get the application configuration."""
@@ -34,52 +30,3 @@ class ApplicationAbstractProtocol(Protocol):
     @abstractmethod
     def get_status_service(self) -> StatusService:
         """Get the status service."""
-
-
-@runtime_checkable
-class PluginProtocol(Protocol):
-    """Defines the protocol for the plugins."""
-
-    @abstractmethod
-    def pre_conditions_check(self, application: ApplicationAbstractProtocol) -> bool:
-        """Check the pre-conditions for the plugin.
-
-        Args:
-            application (BaseApplicationProtocol): The application.
-
-        Returns:
-            bool: True if the pre-conditions are met, False otherwise.
-        """
-
-    @abstractmethod
-    def on_load(self, application: ApplicationAbstractProtocol) -> list["PluginState"] | None:
-        """The actions to perform on load for the plugin.
-
-        Args:
-            application (BaseApplicationProtocol): The application.
-
-        Returns:
-            None
-        """
-
-    @abstractmethod
-    async def on_startup(self, application: ApplicationAbstractProtocol) -> list["PluginState"] | None:
-        """The actions to perform on startup for the plugin.
-
-        Args:
-            application (BaseApplicationProtocol): The application.
-
-        Returns:
-            None
-        """
-
-    @abstractmethod
-    async def on_shutdown(self, application: ApplicationAbstractProtocol) -> None:
-        """The actions to perform on shutdown for the plugin.
-
-        Args:
-            application (BaseApplicationProtocol): The application.
-
-        Returns:
-            None
-        """

fastapi_factory_utilities/core/security/jwt.py

@@ -0,0 +1,159 @@
+"""Provides security-related functions for the API."""
+
+from asyncio import Task, TaskGroup
+from http import HTTPStatus
+from typing import Any, ClassVar, NewType, cast
+
+import jwt
+import pydantic
+from fastapi import Request
+from fastapi.exceptions import HTTPException
+from pydantic import BaseModel
+
+Scope = NewType("Scope", str)
+
+
+class JWTBearerDecoded(BaseModel):
+    """JWT bearer token decoded."""
+
+    model_config: ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="forbid",
+        frozen=True,
+    )
+
+    scopes: list[str] | None = None
+
+
+class JWTBearerAuthentication:
+    """JWT Bearer Authentication.
+
+    This class is used to authenticate users using JWT tokens.
+    It extracts the token from the request, decodes it, and verifies its validity.
+    """
+
+    def __init__(self, scopes: list[Scope] | None = None, jwt_raw: str | None = None) -> None:
+        """Initialize the OAuth2 class.
+
+        Args:
+            scopes (SecurityScopes): Security scopes for the OAuth2.
+            jwt_raw (str): JWT token to be used for authentication.
+        """
+        self.jwt_raw: str | None = jwt_raw
+        self.scopes: list[Scope] | None = scopes
+
+    def _extract_raw_token(self, request: Request) -> str:
+        """Extract the raw token from the request.
+
+        Args:
+            request (Request): FastAPI request object.
+
+        Returns:
+            str: Raw token.
+
+        Raises:
+            HTTPException: If the token is missing or invalid.
+        """
+        try:
+            authorization_header: str | None = request.headers.get("Authorization")
+        except (AttributeError, KeyError) as e:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Missing Credentials") from e
+
+        if not authorization_header:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Missing Credentials")
+
+        if not authorization_header.startswith("Bearer "):
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Invalid Credentials")
+
+        return authorization_header.split(sep=" ")[1]
+
+    async def _decode_jwt(self, jwt_raw: str) -> JWTBearerDecoded:
+        """Decode the JWT token.
+
+        Args:
+            jwt_raw (str): Raw JWT token.
+
+        Returns:
+            JWTBearerDecoded: Decoded JWT token.
+
+        Raises:
+            HTTPException: If the token is invalid or expired.
+        """
+        try:
+            jwt_decoded: dict[str, Any] = cast(
+                dict[str, Any],
+                jwt.decode(
+                    jwt=jwt_raw,
+                    algorithms=["HS256", "RS256"],
+                    options={"verify_signature": True},
+                ),
+            )
+            return JWTBearerDecoded(**jwt_decoded)
+        except jwt.ExpiredSignatureError as e:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Token expired") from e
+        except jwt.InvalidTokenError as e:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Invalid token") from e
+        except pydantic.ValidationError as e:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail=f"Invalid token: {e.json()}") from e
+
+    async def _verify(self, jwt_raw: str) -> None:
+        """Verify the JWT token.
+
+        Args:
+            jwt_raw (str): Raw JWT token.
+        """
+        pass
+
+    def _has_scope(self, jwt_decoded: JWTBearerDecoded) -> None:
+        """Check if the JWT token has the required scope.
+
+        Args:
+            jwt_decoded (JWTBearerDecoded): Decoded JWT token.
+
+        """
+        # Just Authentication (no scopes, no authorization)
+        if not self.scopes:
+            return
+        # JWT without scopes (no authorization)
+        if not jwt_decoded.scopes:
+            raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="Unauthorized")
+        # Check if all required scopes are present
+        if not all(scope in jwt_decoded.scopes for scope in (self.scopes or [])):
+            raise HTTPException(status_code=HTTPStatus.FORBIDDEN, detail="Unauthorized")
+
+        # All scopes are valid (authorization)
+        return
+
+    async def __call__(self, request: Request | None = None) -> JWTBearerDecoded:
+        """Call the JWT bearer authentication.
+
+        Args:
+            request (Request): FastAPI request object.
+
+        Returns:
+            JWTBearerDecoded: Decoded JWT token.
+
+        Raises:
+            HTTPException: If the token is missing or invalid.
+        """
+        # Ensure that the jwt will be provided
+        # by the request or by the jwt parameter
+        if self.jwt_raw is None and request is None:
+            raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED, detail="Missing Credentials")
+        jwt_raw: str
+        if self.jwt_raw is None:
+            jwt_raw = self._extract_raw_token(request=request)  # type: ignore[arg-type]
+        else:
+            jwt_raw = self.jwt_raw
+
+        # Execute the io bound and cpu bound tasks in parallel
+        async with TaskGroup() as tg:
+            # TODO: Can be disabled by configuration (for operation purposes)
+            # Ensure that the jwt is not revoked or expired
+            tg.create_task(self._verify(jwt_raw=jwt_raw), name="verify_jwt")
+            # Ensure that the jwt is not altered or expired
+            task_decode: Task[Any] = tg.create_task(self._decode_jwt(jwt_raw=jwt_raw), name="decode_jwt")
+        # Scope Validation
+        jwt_decoded: JWTBearerDecoded = task_decode.result()
+        self._has_scope(jwt_decoded=jwt_decoded)
+        return jwt_decoded

fastapi_factory_utilities/core/security/kratos.py

@@ -0,0 +1,98 @@
+"""Provide Kratos Session and Identity classes."""
+
+from enum import StrEnum
+from typing import Annotated
+
+from fastapi import Depends, HTTPException, Request
+
+from fastapi_factory_utilities.core.services.kratos import (
+    KratosOperationError,
+    KratosService,
+    KratosSessionInvalidError,
+    KratosSessionObject,
+    depends_kratos_service,
+)
+
+
+class KratosSessionAuthenticationErrors(StrEnum):
+    """Kratos Session Authentication Errors."""
+
+    MISSING_CREDENTIALS = "Missing Credentials"
+    INVALID_CREDENTIALS = "Invalid Credentials"
+    INTERNAL_SERVER_ERROR = "Internal Server Error"
+
+
+class KratosSessionAuthentication:
+    """Kratos Session class."""
+
+    DEFAULT_COOKIE_NAME: str = "ory_kratos_session"
+
+    def __init__(self, cookie_name: str = DEFAULT_COOKIE_NAME, raise_exception: bool = True) -> None:
+        """Initialize the KratosSessionAuthentication class.
+
+        Args:
+            cookie_name (str): Name of the cookie to extract the session
+            raise_exception (bool): Whether to raise an exception or return None
+        """
+        self._cookie_name: str = cookie_name
+        self._raise_exception: bool = raise_exception
+
+    def _extract_cookie(self, request: Request) -> str | None:
+        """Extract the cookie from the request.
+
+        Args:
+            request (Request): FastAPI request object.
+
+        Returns:
+            str | None: Cookie value or None if not found.
+
+        Raises:
+            HTTPException: If the cookie is missing.
+        """
+        return request.cookies.get(self._cookie_name, None)
+
+    async def __call__(
+        self, request: Request, kratos_service: Annotated[KratosService, Depends(depends_kratos_service)]
+    ) -> KratosSessionObject | KratosSessionAuthenticationErrors:
+        """Extract the Kratos session from the request.
+
+        Args:
+            request (Request): FastAPI request object.
+            kratos_service (KratosService): Kratos service object.
+
+        Returns:
+            KratosSessionObject | KratosSessionAuthenticationErrors: Kratos session object or error.
+
+        Raises:
+            HTTPException: If the session is invalid and raise_exception is True.
+        """
+        cookie: str | None = self._extract_cookie(request)
+        if not cookie:
+            if self._raise_exception:
+                raise HTTPException(
+                    status_code=401,
+                    detail=KratosSessionAuthenticationErrors.MISSING_CREDENTIALS,
+                )
+            else:
+                return KratosSessionAuthenticationErrors.MISSING_CREDENTIALS
+
+        try:
+            session: KratosSessionObject = await kratos_service.whoami(cookie_value=cookie)
+        except KratosSessionInvalidError as e:
+            if self._raise_exception:
+                raise HTTPException(
+                    status_code=401,
+                    detail="Invalid Credentials",
+                ) from e
+            else:
+                return KratosSessionAuthenticationErrors.INVALID_CREDENTIALS
+        except KratosOperationError as e:
+            if self._raise_exception:
+                raise HTTPException(
+                    status_code=500,
+                    detail="Internal Server Error",
+                ) from e
+            else:
+                return KratosSessionAuthenticationErrors.INTERNAL_SERVER_ERROR
+
+        return session

fastapi_factory_utilities/core/services/hydra/__init__.py

@@ -0,0 +1,13 @@
+"""Hydra service module."""
+
+from .exceptions import HydraOperationError, HydraTokenInvalidError
+from .objects import HydraTokenIntrospectObject
+from .services import HydraService, depends_hydra_service
+
+__all__: list[str] = [
+    "HydraOperationError",
+    "HydraService",
+    "HydraTokenIntrospectObject",
+    "HydraTokenInvalidError",
+    "depends_hydra_service",
+]

fastapi_factory_utilities/core/services/hydra/exceptions.py

@@ -0,0 +1,15 @@
+"""Python exceptions for the Hydra service."""
+
+from fastapi_factory_utilities.core.exceptions import FastAPIFactoryUtilitiesError
+
+
+class HydraError(FastAPIFactoryUtilitiesError):
+    """Base class for all exceptions raised by the Hydra service."""
+
+
+class HydraOperationError(HydraError):
+    """Exception raised when a Hydra operation fails."""
+
+
+class HydraTokenInvalidError(HydraError):
+    """Exception raised when a Hydra token is invalid."""

fastapi_factory_utilities/core/services/hydra/objects.py

@@ -0,0 +1,26 @@
+"""Provides the objects for the Hydra service."""
+
+from typing import ClassVar
+
+from pydantic import BaseModel, ConfigDict
+
+
+class HydraTokenIntrospectObject(BaseModel):
+    """Represents the object returned by the Hydra token introspection."""
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(extra="ignore")
+
+    active: bool
+    aud: list[str]
+    client_id: str
+    exp: int
+    ext: dict[str, str] | None = None
+    iat: int
+    iss: str
+    nbf: int
+    obfuscated_subject: str | None = None
+    scope: str
+    sub: str
+    token_type: str
+    token_use: str
+    username: str | None = None