fastapi-mongo-base 0.8.30__py3-none-any.whl

fastapi_mongo_base/cached.py

@@ -0,0 +1,115 @@
+import json
+import logging
+import uuid
+
+from pymongo import UpdateOne
+
+from .models import BaseEntity
+from .tasks import TaskStatusEnum
+from .utils import bsontools
+
+try:
+    from server.config import Settings
+except ImportError:
+    from .core.config import Settings
+
+
+try:
+    from server.db import redis
+except ImportError:
+    from redis import Redis
+
+    redis = Redis()
+
+
+class CachedMixin(BaseEntity):
+    def is_done(self):
+        return (
+            getattr(self, "task_status", "done") in TaskStatusEnum.Finishes()
+            or self.is_deleted
+        )
+
+    async def is_cached(self):
+        return await redis.hexists(
+            f"{Settings.project_name}:{self.__class__.__name__}_updates_hash",
+            str(self.uid),
+        )
+
+    async def save(self, *args, **kwargs):
+        if self.is_done():
+            result = await super().save(*args, **kwargs)
+            await redis.hdel(
+                f"{Settings.project_name}:{self.__class__.__name__}_updates_hash",
+                str(self.uid),
+            )
+            return result
+        else:
+            await redis.hset(
+                f"{Settings.project_name}:{self.__class__.__name__}_updates_hash",
+                str(self.uid),
+                self.model_dump_json(),
+            )
+
+    @classmethod
+    async def flush_queue_to_db(cls):
+        # Get all items from the Redis hash in a single operation
+        items_data: dict[bytes, bytes] = await redis.hgetall(
+            f"{Settings.project_name}:{cls.__name__}_updates_hash"
+        )
+
+        # Clear the Redis hash after a successful batch write
+        await redis.delete(f"{Settings.project_name}:{cls.__name__}_updates_hash")
+
+        if items_data:
+            # Create a list of MongoDB upsert operations for the bulk update/insert
+            bulk_operations = []
+            for uid_bytes, item_data in items_data.items():
+                item_dict = json.loads(item_data)
+                item = cls(**item_dict)
+                uid = uuid.UUID(uid_bytes.decode("utf-8"))
+                filter_query = {"uid": bsontools.get_bson_value(uid)}
+                # Assuming the unique identifier is stored in _id
+                logging.info(
+                    f"Flushing item {uid} to DB {bsontools.get_bson_value(item.model_dump())}"
+                )
+                update_query = {"$set": bsontools.get_bson_value(item.model_dump())}
+                bulk_operations.append(
+                    UpdateOne(filter_query, update_query, upsert=True)
+                )
+
+            # Perform the bulk upsert operation in a single call
+            if bulk_operations:
+                res = await cls.get_motor_collection().bulk_write(bulk_operations)
+                logging.info(f"Flushed {len(bulk_operations)} items to DB \n{res}")
+
+    @classmethod
+    async def get_item(
+        cls,
+        uid,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        is_deleted: bool = False,
+        *args,
+        **kwargs,
+    ) -> BaseEntity:
+        if user_id == None and kwargs.get("ignore_user_id") != True:
+            raise ValueError("user_id is required")
+        item_data = await redis.hget(
+            f"{Settings.project_name}:{cls.__name__}_updates_hash", str(uid)
+        )
+        if item_data:
+            item_dict = json.loads(item_data)
+            item = cls(**item_dict)
+            if user_id and getattr(item, "user_id", None) != user_id:
+                return None
+            if getattr(item, "business_name", None) != business_name:
+                return None
+            return item
+        return await super().get_item(
+            uid,
+            business_name=business_name,
+            user_id=user_id,
+            is_deleted=is_deleted,
+            *args,
+            **kwargs,
+        )

fastapi_mongo_base/core/app_factory.py

@@ -0,0 +1,184 @@
+import asyncio
+import logging
+from collections import deque
+from contextlib import asynccontextmanager
+
+import fastapi
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from fastapi_mongo_base.core import db, exceptions
+
+try:
+    from server.config import Settings
+except ImportError:
+    from .config import Settings
+
+
+async def health(request: fastapi.Request):
+    return {
+        "status": "up",
+        "host": request.url.hostname,
+        # "host2": request.base_url.hostname,
+        # "original_host":request.headers.get("x-original-host", "!not found!"),
+        # "forwarded_host": request.headers.get("X-Forwarded-Host", "forwarded_host"),
+        # "forwarded_proto": request.headers.get("X-Forwarded-Proto", "forwarded_proto"),
+        # "forwarded_for": request.headers.get("X-Forwarded-For", "forwarded_for"),
+    }
+
+
+@asynccontextmanager
+async def lifespan(app: fastapi.FastAPI, worker=None, init_functions=[], settings: Settings = None):  # type: ignore
+    """Initialize application services."""
+    await db.init_mongo_db()
+
+    if worker:
+        app.state.worker = asyncio.create_task(worker())
+
+    for function in init_functions:
+        if asyncio.iscoroutinefunction(function):
+            await function()
+        else:
+            function()
+
+    logging.info("Startup complete")
+    yield
+    app.state.worker.cancel()
+    logging.info("Shutdown complete")
+
+
+def setup_exception_handlers(
+    app: fastapi.FastAPI,
+    usso_handler: bool = True,
+    ufaas_handler: bool = True,
+    **kwargs,
+):
+    exception_handlers = exceptions.EXCEPTION_HANDLERS
+    if usso_handler:
+        from usso.fastapi.integration import (
+            EXCEPTION_HANDLERS as USSO_EXCEPTION_HANDLERS,
+        )
+
+        exception_handlers.update(USSO_EXCEPTION_HANDLERS)
+    if ufaas_handler:
+        from ufaas.fastapi.integration import (
+            EXCEPTION_HANDLERS as UFAAS_EXCEPTION_HANDLERS,
+        )
+
+        exception_handlers.update(UFAAS_EXCEPTION_HANDLERS)
+
+    for exc_class, handler in exception_handlers.items():
+        app.exception_handler(exc_class)(handler)
+
+
+def setup_middlewares(
+    app: fastapi.FastAPI,
+    origins: list = None,
+    original_host_middleware: bool = False,
+    request_log_middleware: bool = False,
+    **kwargs,
+):
+    if origins:
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=origins,
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+    if original_host_middleware:
+        from ufaas_fastapi_business.core.middlewares import OriginalHostMiddleware
+
+        app.add_middleware(OriginalHostMiddleware)
+    if request_log_middleware:
+        from .middlewares import RequestLoggingMiddleware
+
+        app.add_middleware(RequestLoggingMiddleware)
+
+
+def create_app(
+    *,
+    settings: Settings = None,
+    title=None,
+    description=None,
+    version="0.1.0",
+    serve_coverage: bool = False,
+    origins: list = None,
+    lifespan_func=None,
+    worker=None,
+    init_functions: list = [],
+    contact={
+        "name": "Mahdi Kiani",
+        "url": "https://github.com/mahdikiani/FastAPILaunchpad",
+        "email": "mahdikiany@gmail.com",
+    },
+    license_info={
+        "name": "MIT License",
+        "url": "https://github.com/mahdikiani/FastAPILaunchpad/blob/main/LICENSE",
+    },
+    usso_handler: bool = True,
+    ufaas_handler: bool = True,
+    original_host_middleware: bool = False,
+    request_log_middleware: bool = False,
+    **kwargs,
+) -> fastapi.FastAPI:
+    settings.config_logger()
+
+    """Create a FastAPI app with shared configurations."""
+    if settings is None:
+        settings = Settings()
+    if title is None:
+        title = settings.project_name.replace("-", " ").title()
+    if description is None:
+        description = getattr(settings, "project_description", None)
+    if version is None:
+        version = getattr(settings, "project_version", "0.1.0")
+    base_path: str = settings.base_path
+
+    if origins is None:
+        origins = ["http://localhost:8000"]
+
+    if lifespan_func is None:
+        lifespan_func = lambda app: lifespan(app, worker, init_functions, settings)
+
+    docs_url = f"{base_path}/docs"
+    openapi_url = f"{base_path}/openapi.json"
+
+    app = fastapi.FastAPI(
+        title=title,
+        version=version,
+        description=description,
+        lifespan=lifespan_func,
+        contact=contact,
+        license_info=license_info,
+        docs_url=docs_url,
+        openapi_url=openapi_url,
+    )
+
+    setup_exception_handlers(app, usso_handler, ufaas_handler, **kwargs)
+    setup_middlewares(
+        app,
+        origins,
+        original_host_middleware,
+        request_log_middleware,
+        **kwargs,
+    )
+
+    async def logs():
+        with open(settings.get_log_config()["info_log_path"], "rb") as f:
+            last_100_lines = deque(f, maxlen=100)
+
+        return [line.decode("utf-8") for line in last_100_lines]
+
+    app.get(f"{base_path}/health")(health)
+    app.get(f"{base_path}/logs", include_in_schema=False)(logs)
+
+    if serve_coverage:
+        app.mount(
+            f"{settings.base_path}/coverage",
+            StaticFiles(directory=settings.get_coverage_dir()),
+            name="coverage",
+        )
+
+    return app

fastapi_mongo_base/core/config.py

@@ -0,0 +1,84 @@
+"""FastAPI server configuration."""
+
+import dataclasses
+import logging
+import logging.config
+import os
+
+import dotenv
+from singleton import Singleton
+
+dotenv.load_dotenv()
+
+
+@dataclasses.dataclass
+class Settings(metaclass=Singleton):
+    """Server config settings."""
+
+    # base_dir: Path = Path(__file__).resolve().parent.parent
+    root_url: str = os.getenv("DOMAIN", default="http://localhost:8000")
+    project_name: str = os.getenv("PROJECT_NAME", default="PROJECT")
+    base_path: str = "/api/v1"
+    worker_update_time: int = int(os.getenv("WORKER_UPDATE_TIME", default=180))
+    testing: bool = os.getenv("DEBUG", default=False)
+
+    page_max_limit: int = 100
+
+    mongo_uri: str = os.getenv("MONGO_URI", default="mongodb://localhost:27017/")
+    redis_uri: str = os.getenv("REDIS_URI", default="redis://localhost:6379/0")
+
+    app_id: str = os.getenv("APP_ID")
+    app_secret: str = os.getenv("APP_SECRET")
+
+    JWT_CONFIG: str = os.getenv(
+        "USSO_JWT_CONFIG",
+        default='{"jwk_url": "https://sso.usso.io/website/jwks.json","type": "RS256","header": {"type": "Cookie", "name": "usso_access_token"} }',
+    )
+
+    @classmethod
+    def get_coverage_dir(cls):
+        return cls.base_dir / "htmlcov"
+
+    @classmethod
+    def get_log_config(cls, console_level: str = "INFO", file_level: str = "INFO", **kwargs):
+        log_config = {
+            "formatters": {
+                "standard": {
+                    "format": "[{levelname} : {filename}:{lineno} : {asctime} -> {funcName:10}] {message}",
+                    "style": "{",
+                }
+            },
+            "handlers": {
+                "console": {
+                    "class": "logging.StreamHandler",
+                    "level": console_level,
+                    "formatter": "standard",
+                },
+                "file": {
+                    "class": "logging.FileHandler",
+                    "level": file_level,
+                    "filename": cls.base_dir / "logs" / "info.log",
+                    "formatter": "standard",
+                },
+            },
+            "loggers": {
+                "": {
+                    "handlers": ["console", "file"],
+                    "level": "INFO",
+                    "propagate": True,
+                },
+                "httpx": {  
+                    "handlers": ["console", "file"], 
+                    "level": "WARNING",
+                    "propagate": False,
+                },
+            },
+            "version": 1,
+        }
+        return log_config
+
+    @classmethod
+    def config_logger(cls):
+        (cls.base_dir / "logs").mkdir(parents=True, exist_ok=True)
+        
+        logging.config.dictConfig(cls.get_log_config())

fastapi_mongo_base/core/db.py

@@ -0,0 +1,45 @@
+import logging
+
+from beanie import init_beanie
+from motor.motor_asyncio import AsyncIOMotorClient
+
+from fastapi_mongo_base.models import BaseEntity
+from fastapi_mongo_base.utils import basic
+
+try:
+    from server.config import Settings
+except ImportError:
+    from .config import Settings
+
+
+async def init_mongo_db():
+    client = AsyncIOMotorClient(Settings.mongo_uri)
+    db = client.get_database(Settings.project_name)
+    await init_beanie(
+        database=db,
+        document_models=[
+            cls
+            for cls in basic.get_all_subclasses(BaseEntity)
+            if not (
+                hasattr(cls, "Settings")
+                and getattr(cls.Settings, "__abstract__", False)
+            )
+        ],
+    )
+    return db
+
+
+def init_redis():
+    try:
+        from redis import Redis as RedisSync
+        from redis.asyncio.client import Redis
+
+        if getattr(Settings, "redis_uri"):
+            redis_sync: RedisSync = RedisSync.from_url(Settings.redis_uri)
+            redis: Redis = Redis.from_url(Settings.redis_uri)
+    except ImportError or AttributeError or Exception as e:
+        logging.error(f"Error initializing Redis: {e}")
+        redis_sync = None
+        redis = None
+
+    return redis_sync, redis

fastapi_mongo_base/core/enums.py

@@ -0,0 +1,36 @@
+from enum import Enum
+
+
+class Language(str, Enum):
+    English = "English"
+    Persian = "Persian"
+
+    @classmethod
+    def has_value(cls, value):
+        return value in cls._value2member_map_
+
+    @property
+    def fa(self):
+        return {
+            Language.English: "انگلیسی",
+            Language.Persian: "فارسی",
+        }[self]
+
+    @property
+    def abbreviation(self):
+        return {
+            Language.English: "en",
+            Language.Persian: "fa",
+        }[self]
+
+    def get_dict(self):
+        return {
+            "en": self.name,
+            "fa": self.fa,
+            "value": self.value,
+            "abbreviation": self.abbreviation,
+        }
+
+    @classmethod
+    def get_choices(cls):
+        return [item.get_dict() for item in cls]

fastapi_mongo_base/core/exceptions.py

@@ -0,0 +1,86 @@
+import json
+import logging
+import traceback
+
+import json_advanced
+from fastapi import Request
+from fastapi.exceptions import (
+    HTTPException,
+    RequestValidationError,
+    ResponseValidationError,
+)
+from fastapi.responses import JSONResponse
+from pydantic import ValidationError
+
+error_messages = {}
+
+
+class BaseHTTPException(HTTPException):
+    def __init__(
+        self,
+        status_code: int,
+        error: str,
+        message: str = None,
+        detail: str = None,
+        **kwargs,
+    ):
+        self.status_code = status_code
+        self.error = error
+        self.message = message
+        if message is None:
+            self.message = error_messages.get(error, error)
+        if detail is None:
+            detail = self.message
+        self.detail = detail
+        super().__init__(status_code, detail=detail, **kwargs)
+
+
+async def base_http_exception_handler(request: Request, exc: BaseHTTPException):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"message": exc.message, "error": exc.error},
+    )
+
+
+async def pydantic_exception_handler(request: Request, exc: ValidationError):
+    return JSONResponse(
+        status_code=500,
+        content={
+            "message": str(exc),
+            "error": "Exception",
+            "errors": json.loads(json_advanced.dumps(exc.errors())),
+        },
+    )
+
+
+async def request_validation_exception_handler(
+    request: Request, exc: RequestValidationError
+):
+    logging.error(
+        f"request_validation_exception: {request.url} {exc}\n{(await request.body())[:100]}"
+    )
+    from fastapi.exception_handlers import (
+        request_validation_exception_handler as default_handler,
+    )
+
+    return await default_handler(request, exc)
+
+
+async def general_exception_handler(request: Request, exc: Exception):
+    traceback_str = "".join(traceback.format_tb(exc.__traceback__))
+    logging.error(f"Exception: {traceback_str} {exc}")
+    logging.error(f"Exception on request: {request.url}")
+    return JSONResponse(
+        status_code=500,
+        content={"message": str(exc), "error": "Exception"},
+    )
+
+
+# A dictionary for dynamic registration
+EXCEPTION_HANDLERS = {
+    BaseHTTPException: base_http_exception_handler,
+    ValidationError: pydantic_exception_handler,
+    ResponseValidationError: pydantic_exception_handler,
+    RequestValidationError: request_validation_exception_handler,
+    Exception: general_exception_handler,
+}

fastapi_mongo_base/core/middlewares.py

@@ -0,0 +1,22 @@
+import logging
+
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+
+# Create logging middleware
+class RequestLoggingMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        # Log the request details
+        # logging.info(f"Request: {request.method} {request.url}")
+        # logging.info(f"Headers: {request.headers}")
+
+        # You can also log other request details like body, client IP, etc.
+        # Accessing the request body requires it to be async, managing it carefully since it is a stream
+
+        response = await call_next(request)
+
+        # You can also log response details here if needed
+        logging.info(f"request: {request.method} {request.url} {response.status_code}")
+
+        return response

fastapi_mongo_base/handlers.py

@@ -0,0 +1,39 @@
+import uuid
+from typing import TypeVar
+
+from fastapi import Request
+
+from .schemas import BaseEntitySchema, OwnedEntitySchema
+
+T = TypeVar("T", bound=BaseEntitySchema)
+OT = TypeVar("OT", bound=OwnedEntitySchema)
+
+
+def create_dto(cls: OT):
+    async def dto(
+        request: Request,
+        *,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        **kwargs,
+    ):
+        form_data = await request.json()
+
+        if hasattr(cls, "create_field_set") and cls.create_field_set():
+            for key in form_data.keys():
+                if key not in cls.create_field_set():
+                    form_data.pop(key, None)
+
+        if hasattr(cls, "create_exclude_set") and cls.create_exclude_set():
+            for key in cls.create_exclude_set():
+                form_data.pop(key, None)
+
+        if user_id:
+            form_data["user_id"] = user_id
+
+        if business_name:
+            form_data["business_name"] = business_name
+
+        return cls(**form_data)
+
+    return dto