fastapi-mongo-base 1.4.2__tar.gz → 1.5.0__tar.gz

{fastapi_mongo_base-1.4.2/src/fastapi_mongo_base.egg-info → fastapi_mongo_base-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-mongo-base
-Version: 1.4.2
+Version: 1.5.0
 Summary: A simple boilerplate application, including models and schemas and abstract router, for FastAPI with MongoDB
 Author-email: Mahdi Kiani <mahdikiany@gmail.com>
 Maintainer-email: Mahdi Kiani <mahdikiany@gmail.com>
@@ -38,14 +38,25 @@ Provides-Extra: usso
 Requires-Dist: usso>=0.30.1; extra == "usso"
 Provides-Extra: sql
 Requires-Dist: sqlalchemy>=2.0.43; extra == "sql"
+Requires-Dist: aiosqlite>=0.20.0; extra == "sql"
+Requires-Dist: greenlet>=3.0.0; extra == "sql"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: pytest-asyncio; extra == "test"
 Requires-Dist: mongomock_motor; extra == "test"
 Requires-Dist: coverage; extra == "test"
+Requires-Dist: sqlalchemy>=2.0.43; extra == "test"
+Requires-Dist: aiosqlite>=0.20.0; extra == "test"
+Requires-Dist: greenlet>=3.0.0; extra == "test"
+Requires-Dist: prometheus-client>=0.25.0; extra == "test"
+Requires-Dist: redis>=8.0.0; extra == "test"
+Provides-Extra: monitoring
+Requires-Dist: prometheus-client>=0.25.0; extra == "monitoring"
 Provides-Extra: prometheus
 Requires-Dist: prometheus-client>=0.25.0; extra == "prometheus"
+Provides-Extra: redis
+Requires-Dist: redis>=5.0.0; extra == "redis"
 Provides-Extra: sentry
 Requires-Dist: sentry-sdk[fastapi]>=2.0.0; extra == "sentry"
 Dynamic: license-file

{fastapi_mongo_base-1.4.2 → fastapi_mongo_base-1.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastapi-mongo-base"
-version = "1.4.2"
+version = "1.5.0"
 description = "A simple boilerplate application, including models and schemas and abstract router, for FastAPI with MongoDB"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -40,9 +40,22 @@ dependencies = [
 
 [project.optional-dependencies]
 usso = ["usso>=0.30.1"]
-sql = ["sqlalchemy>=2.0.43"]
-test = ["pytest", "pytest-cov", "pytest-asyncio", "mongomock_motor", "coverage"]
+sql = ["sqlalchemy>=2.0.43", "aiosqlite>=0.20.0", "greenlet>=3.0.0"]
+test = [
+    "pytest",
+    "pytest-cov",
+    "pytest-asyncio",
+    "mongomock_motor",
+    "coverage",
+    "sqlalchemy>=2.0.43",
+    "aiosqlite>=0.20.0",
+    "greenlet>=3.0.0",
+    "prometheus-client>=0.25.0",
+    "redis>=8.0.0",
+]
+monitoring = ["prometheus-client>=0.25.0"]
 prometheus = ["prometheus-client>=0.25.0"]
+redis = ["redis>=5.0.0"]
 sentry = ["sentry-sdk[fastapi]>=2.0.0"]
 
 [project.urls]

{fastapi_mongo_base-1.4.2 → fastapi_mongo_base-1.5.0}/pytest.ini

@@ -1,5 +1,7 @@
 [pytest]
-pythonpath = .
+pythonpath =
+    src
+    .
 testpaths = tests
 
 asyncio_mode = auto
@@ -9,7 +11,7 @@ addopts =
     --cov=src
     --cov-report=term-missing
     --cov-report=html
-    --cov-fail-under=25
+    --cov-fail-under=50
 
 filterwarnings =
     ignore:.*model_fields.*:DeprecationWarning

{fastapi_mongo_base-1.4.2 → fastapi_mongo_base-1.5.0}/src/fastapi_mongo_base/__init__.py

@@ -1,5 +1,5 @@
 """FastAPI MongoDB base package with models, schemas, and routers."""
 
-from .core import exceptions
+from . import errors
 
-__all__ = ["exceptions"]
+__all__ = ["errors"]

{fastapi_mongo_base-1.4.2 → fastapi_mongo_base-1.5.0}/src/fastapi_mongo_base/core/app_factory.py

@@ -8,26 +8,151 @@ from collections.abc import AsyncGenerator, Callable
 from contextlib import asynccontextmanager
 
 import fastapi
-from fastapi.responses import RedirectResponse
+from fastapi.responses import JSONResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
 
-from . import config, db, exceptions
-from .error_responses import COMMON_ERROR_RESPONSES, setup_openapi_errors
-from .sentry import setup_sentry
+from ..errors.handlers import EXCEPTION_HANDLERS
+from ..errors.responses import COMMON_ERROR_RESPONSES, setup_openapi_errors
+from ..monitoring.sentry import setup_sentry
+from . import config, db
 
 
-def health(request: fastapi.Request) -> dict[str, str]:
+def _is_configured_uri(value: str | None) -> bool:
+    return bool(value and str(value).strip())
+
+
+def _use_mongodb(settings: config.Settings | None) -> bool:
+    if settings is None:
+        return False
+    return _is_configured_uri(getattr(settings, "mongo_uri", None))
+
+
+def _use_redis(settings: config.Settings | None) -> bool:
+    if settings is None:
+        return False
+    return _is_configured_uri(getattr(settings, "redis_uri", None))
+
+
+def _use_sql(settings: config.Settings | None) -> bool:
+    if settings is None:
+        return False
+    return _is_configured_uri(getattr(settings, "database_uri", None))
+
+
+def health(request: fastapi.Request) -> dict[str, object]:
+    """
+    Liveness probe endpoint handler.
+
+    Args:
+        request: FastAPI request object.
+
+    Returns:
+        Dictionary with status and optional version.
+
+    """
+    payload: dict[str, object] = {"status": "up"}
+
+    if request.app.version:
+        payload["version"] = request.app.version
+    return payload
+
+
+async def readiness(request: fastapi.Request) -> JSONResponse:
     """
-    Health check endpoint handler.
+    Readiness probe endpoint handler.
 
     Args:
         request: FastAPI request object.
 
     Returns:
-        Dictionary with status "up".
+        JSON response with dependency checks and HTTP 503 when degraded.
 
     """
-    return {"status": "up"}
+    datasources = getattr(request.app.state, "datasources", {})
+    mongo_client = getattr(request.app.state, "mongo_client", None)
+    redis_client = getattr(request.app.state, "redis_async_client", None)
+    sql_session = getattr(request.app.state, "async_session", None)
+
+    checks: dict[str, str] = {}
+    if datasources.get("mongodb"):
+        checks["mongodb"] = await db.check_mongodb(mongo_client)
+    else:
+        checks["mongodb"] = "skipped"
+
+    if datasources.get("redis"):
+        checks["redis"] = await db.check_redis(redis_client)
+    else:
+        checks["redis"] = "skipped"
+
+    if datasources.get("sql"):
+        checks["sql"] = await db.check_sql(sql_session)
+    else:
+        checks["sql"] = "skipped"
+
+    is_ready = "down" not in checks.values()
+    payload: dict[str, object] = {
+        "status": "up" if is_ready else "degraded",
+        "checks": checks,
+    }
+    if request.app.version:
+        payload["version"] = request.app.version
+
+    return JSONResponse(
+        status_code=fastapi.status.HTTP_200_OK
+        if is_ready
+        else fastapi.status.HTTP_503_SERVICE_UNAVAILABLE,
+        content=payload,
+    )
+
+
+async def _startup_datasources(
+    app: fastapi.FastAPI,
+    settings: config.Settings | None,
+) -> None:
+    use_mongo = _use_mongodb(settings)
+    use_redis = _use_redis(settings)
+    use_sql = _use_sql(settings)
+    app.state.datasources = {
+        "mongodb": use_mongo,
+        "redis": use_redis,
+        "sql": use_sql,
+    }
+
+    if use_mongo:
+        mongo_db, mongo_client = await db.init_mongo_db(settings)
+    else:
+        mongo_db, mongo_client = None, None
+    app.state.mongo_db = mongo_db
+    app.state.mongo_client = mongo_client
+
+    if use_redis:
+        redis_sync, redis_async = db.init_redis(settings)
+    else:
+        redis_sync, redis_async = None, None
+    app.state.redis_sync_client = redis_sync
+    app.state.redis_async_client = redis_async
+
+    if use_sql:
+        sql_engine, sql_session = await db.init_sql(settings)
+    else:
+        sql_engine, sql_session = None, None
+    app.state.sql_engine = sql_engine
+    app.state.async_session = sql_session
+
+
+async def _shutdown_datasources(app: fastapi.FastAPI) -> None:
+    if getattr(app.state, "mongo_client", None) is not None:
+        await db.close_mongo_client(app.state.mongo_client)
+    if (
+        getattr(app.state, "redis_sync_client", None) is not None
+        or getattr(app.state, "redis_async_client", None) is not None
+    ):
+        await db.close_redis(
+            getattr(app.state, "redis_sync_client", None),
+            getattr(app.state, "redis_async_client", None),
+        )
+    if getattr(app.state, "sql_engine", None) is not None:
+        await db.close_sql(app.state.sql_engine)
 
 
 @asynccontextmanager
@@ -53,7 +178,10 @@ async def lifespan(
     """
     if init_functions is None:
         init_functions = []
-    await db.init_mongo_db(settings)
+    if settings is not None:
+        app.state.settings = settings
+
+    await _startup_datasources(app, settings)
 
     if worker:
         app.state.worker = asyncio.create_task(worker())
@@ -70,6 +198,7 @@ async def lifespan(
     finally:
         if worker:
             app.state.worker.cancel()
+        await _shutdown_datasources(app)
         logging.info("Shutdown complete")
 
 
@@ -85,7 +214,7 @@ def setup_exception_handlers(
         **kwargs: Additional keyword arguments.
 
     """
-    exception_handlers = exceptions.EXCEPTION_HANDLERS
+    exception_handlers = EXCEPTION_HANDLERS
     if handlers:
         exception_handlers.update(handlers)
 
@@ -218,6 +347,7 @@ def create_app(
     exception_handlers: dict | None = None,
     log_route: bool = False,
     health_route: bool = True,
+    readiness_route: bool = True,
     index_route: bool = True,
     **kwargs: object,
 ) -> fastapi.FastAPI:
@@ -238,7 +368,8 @@ def create_app(
         license_info: Optional license information dictionary.
         exception_handlers: Optional exception handlers dictionary.
         log_route: Whether to enable log viewing route.
-        health_route: Whether to enable health check route.
+        health_route: Whether to enable liveness health check route.
+        readiness_route: Whether to enable readiness health check route.
         index_route: Whether to enable index redirect route.
         **kwargs: Additional keyword arguments.
 
@@ -274,6 +405,7 @@ def create_app(
         exception_handlers=exception_handlers,
         log_route=log_route,
         health_route=health_route,
+        readiness_route=readiness_route,
         index_route=index_route,
         **kwargs,
     )
@@ -290,6 +422,7 @@ def configure_app(
     exception_handlers: dict | None = None,
     log_route: bool = False,
     health_route: bool = True,
+    readiness_route: bool = True,
     index_route: bool = True,
     **kwargs: object,
 ) -> fastapi.FastAPI:
@@ -303,7 +436,8 @@ def configure_app(
         origins: Optional list of allowed CORS origins.
         exception_handlers: Optional exception handlers dictionary.
         log_route: Whether to enable log viewing route.
-        health_route: Whether to enable health check route.
+        health_route: Whether to enable liveness health check route.
+        readiness_route: Whether to enable readiness health check route.
         index_route: Whether to enable index redirect route.
         **kwargs: Additional keyword arguments.
 
@@ -349,6 +483,8 @@ def configure_app(
 
     if health_route:
         app.get(f"{base_path}/health")(health)
+    if readiness_route:
+        app.get(f"{base_path}/health/ready")(readiness)
     if log_route:
         app.get(f"{base_path}/logs", include_in_schema=False)(logs)
     if index_route:

{fastapi_mongo_base-1.4.2 → fastapi_mongo_base-1.5.0}/src/fastapi_mongo_base/core/config.py

@@ -2,7 +2,6 @@
 
 import dataclasses
 import json
-import logging
 import logging.config
 from pathlib import Path
 from typing import Literal
@@ -11,31 +10,7 @@ from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from singleton import Singleton
 
-
-class JsonFormatter(logging.Formatter):
-    """
-    Logging formatter that outputs a single-line structured JSON object.
-
-    Using json_advanced.dumps ensures special types (datetime, UUID,
-    ObjectId, Pydantic models, etc.) are serialised without raising errors.
-    """
-
-    def format(self, record: logging.LogRecord) -> str:
-        """Serialise *record* to a JSON string."""
-        data: dict[str, object] = {
-            "timestamp": self.formatTime(record, self.datefmt),
-            "level": record.levelname,
-            "logger": record.name,
-            "filename": record.filename,
-            "lineno": record.lineno,
-            "funcName": record.funcName,
-            "message": record.getMessage(),
-        }
-        if record.exc_info:
-            data["exc_info"] = self.formatException(record.exc_info)
-        if record.stack_info:
-            data["stack_info"] = self.formatStack(record.stack_info)
-        return json.dumps(data, ensure_ascii=False)
+from ..logging.formatters import JsonFormatter
 
 
 class ProjectSettings(BaseSettings):
@@ -79,9 +54,7 @@ class ProjectSettings(BaseSettings):
         validation_alias="CORS_ORIGINS",
     )
     page_max_limit: int = 100
-    mongo_uri: str = Field(
-        default="mongodb://localhost:27017/", validation_alias="MONGO_URI"
-    )
+    mongo_uri: str | None = Field(default=None, validation_alias="MONGO_URI")
     mongo_server_selection_timeout_ms: int = 5000
     mongo_connect_timeout_ms: int = 5000
     sentry_dsn: str | None = Field(default=None, validation_alias="SENTRY_DSN")
@@ -105,6 +78,34 @@ class ProjectSettings(BaseSettings):
         default=False,
         validation_alias="SENTRY_SEND_DEFAULT_PII",
     )
+    redis_uri: str | None = Field(default=None, validation_alias="REDIS_URI")
+    database_uri: str | None = Field(
+        default=None,
+        validation_alias="DATABASE_URI",
+    )
+    database_echo: bool = Field(
+        default=False, validation_alias="DATABASE_ECHO"
+    )
+    database_pool_size: int | None = Field(
+        default=None,
+        validation_alias="DATABASE_POOL_SIZE",
+    )
+    database_max_overflow: int | None = Field(
+        default=None,
+        validation_alias="DATABASE_MAX_OVERFLOW",
+    )
+    database_pool_timeout: int | None = Field(
+        default=None,
+        validation_alias="DATABASE_POOL_TIMEOUT",
+    )
+    database_pool_pre_ping: bool = Field(
+        default=True,
+        validation_alias="DATABASE_POOL_PRE_PING",
+    )
+    database_pool_recycle: int | None = Field(
+        default=None,
+        validation_alias="DATABASE_POOL_RECYCLE",
+    )
     log_format: Literal["json", "text"] = Field(
         default="json",
         validation_alias="LOG_FORMAT",
@@ -216,7 +217,7 @@ class Settings(metaclass=Singleton):
         return ["http://localhost:8000"]
 
     page_max_limit: int = project_settings.page_max_limit
-    mongo_uri: str = project_settings.mongo_uri
+    mongo_uri: str | None = project_settings.mongo_uri
     mongo_server_selection_timeout_ms: int = (
         project_settings.mongo_server_selection_timeout_ms
     )
@@ -231,6 +232,14 @@ class Settings(metaclass=Singleton):
         project_settings.sentry_profiles_sample_rate
     )
     sentry_send_default_pii: bool = project_settings.sentry_send_default_pii
+    redis_uri: str | None = project_settings.redis_uri
+    database_uri: str | None = project_settings.database_uri
+    database_echo: bool = project_settings.database_echo
+    database_pool_size: int | None = project_settings.database_pool_size
+    database_max_overflow: int | None = project_settings.database_max_overflow
+    database_pool_timeout: int | None = project_settings.database_pool_timeout
+    database_pool_pre_ping: bool = project_settings.database_pool_pre_ping
+    database_pool_recycle: int | None = project_settings.database_pool_recycle
     log_format: str = project_settings.log_format
 
     @classmethod

fastapi_mongo_base-1.5.0/src/fastapi_mongo_base/core/db.py

@@ -0,0 +1,37 @@
+"""Backward compatibility shim. Prefer fastapi_mongo_base.db."""
+
+from ..db import (
+    check_mongodb,
+    check_redis,
+    check_sql,
+    close_mongo_client,
+    close_redis,
+    close_sql,
+    create_sql_tables,
+    discover_beanie_document_models,
+    get_redis_async_client,
+    get_redis_sync_client,
+    get_sql_engine,
+    get_sql_session_factory,
+    init_mongo_db,
+    init_redis,
+    init_sql,
+)
+
+__all__ = [
+    "check_mongodb",
+    "check_redis",
+    "check_sql",
+    "close_mongo_client",
+    "close_redis",
+    "close_sql",
+    "create_sql_tables",
+    "discover_beanie_document_models",
+    "get_redis_async_client",
+    "get_redis_sync_client",
+    "get_sql_engine",
+    "get_sql_session_factory",
+    "init_mongo_db",
+    "init_redis",
+    "init_sql",
+]

fastapi_mongo_base-1.5.0/src/fastapi_mongo_base/core/exceptions.py

@@ -0,0 +1,23 @@
+"""Backward-compatible re-exports for exception handlers."""
+
+from ..errors.base import BaseHTTPException
+from ..errors.handlers import (
+    EXCEPTION_HANDLERS,
+    base_http_exception_handler,
+    error_messages,
+    general_exception_handler,
+    mongodb_exception_handler,
+    pydantic_exception_handler,
+    request_validation_exception_handler,
+)
+
+__all__ = [
+    "EXCEPTION_HANDLERS",
+    "BaseHTTPException",
+    "base_http_exception_handler",
+    "error_messages",
+    "general_exception_handler",
+    "mongodb_exception_handler",
+    "pydantic_exception_handler",
+    "request_validation_exception_handler",
+]

fastapi_mongo_base-1.5.0/src/fastapi_mongo_base/db/__init__.py

@@ -0,0 +1,41 @@
+"""Database connection initialization for MongoDB and Redis."""
+
+from .mongo import (
+    check_mongodb,
+    close_mongo_client,
+    discover_beanie_document_models,
+    init_mongo_db,
+)
+from .redis import (
+    check_redis,
+    close_redis,
+    get_redis_async_client,
+    get_redis_sync_client,
+    init_redis,
+)
+from .sql import (
+    check_sql,
+    close_sql,
+    create_sql_tables,
+    get_sql_engine,
+    get_sql_session_factory,
+    init_sql,
+)
+
+__all__ = [
+    "check_mongodb",
+    "check_redis",
+    "check_sql",
+    "close_mongo_client",
+    "close_redis",
+    "close_sql",
+    "create_sql_tables",
+    "discover_beanie_document_models",
+    "get_redis_async_client",
+    "get_redis_sync_client",
+    "get_sql_engine",
+    "get_sql_session_factory",
+    "init_mongo_db",
+    "init_redis",
+    "init_sql",
+]