fastapi-mongo-base 0.8.30__tar.gz

fastapi_mongo_base-0.8.30/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2016 The Python Packaging Authority (PyPA)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastapi_mongo_base-0.8.30/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.2
+Name: fastapi-mongo-base
+Version: 0.8.30
+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>
+License: Copyright (c) 2016 The Python Packaging Authority (PyPA)
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of
+        this software and associated documentation files (the "Software"), to deal in
+        the Software without restriction, including without limitation the rights to
+        use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+        of the Software, and to permit persons to whom the Software is furnished to do
+        so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/mahdikiani/fastapi-mongo-base-app
+Project-URL: Bug Reports, https://github.com/mahdikiani/fastapi-mongo-base-app/issues
+Project-URL: Funding, https://github.com/mahdikiani/fastapi-mongo-base-app
+Project-URL: Say Thanks!, https://saythanks.io/to/mahdikiani
+Project-URL: Source, https://github.com/mahdikiani/fastapi-mongo-base-app
+Keywords: fastapi,mongodb,beanie
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: pydantic>=1.8.2
+Requires-Dist: requests>=2.26.0
+Requires-Dist: pyjwt[crypto]
+Requires-Dist: singleton_package
+Requires-Dist: fastapi>=0.65.0
+Requires-Dist: uvicorn[standard]>=0.13.0
+Provides-Extra: image
+Requires-Dist: Pillow>=9.0.0; extra == "image"
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+Provides-Extra: image-similarity
+Requires-Dist: numpy>=1.21.0; extra == "image-similarity"
+Requires-Dist: imagededup>=0.3.0; extra == "image-similarity"
+Provides-Extra: all
+Requires-Dist: Pillow>=9.0.0; extra == "all"
+Requires-Dist: numpy>=1.21.0; extra == "all"
+Requires-Dist: imagededup>=0.3.0; extra == "all"
+
+# Fastapi Mongo 
+
+## Contributing
+Contributions are welcome! See CONTRIBUTING.md for more details on how to get involved.
+
+## License
+Distributed under the MIT License. See LICENSE for more information.

fastapi_mongo_base-0.8.30/README.md

@@ -0,0 +1,7 @@
+# Fastapi Mongo 
+
+## Contributing
+Contributions are welcome! See CONTRIBUTING.md for more details on how to get involved.
+
+## License
+Distributed under the MIT License. See LICENSE for more information.

fastapi_mongo_base-0.8.30/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fastapi-mongo-base"
+version = "0.8.30"
+description = "A simple boilerplate application, including models and schemas and abstract router, for FastAPI with MongoDB"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {file = "LICENSE.txt"}
+keywords = ["fastapi", "mongodb", "beanie"]
+authors = [
+  {name = "Mahdi Kiani", email = "mahdikiany@gmail.com"}
+]
+maintainers = [
+  {name = "Mahdi Kiani", email = "mahdikiany@gmail.com"}
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Build Tools",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3 :: Only",
+]
+dependencies = [
+  "pydantic>=1.8.2",
+  "requests>=2.26.0",
+  "pyjwt[crypto]",
+  "singleton_package",
+  "fastapi>=0.65.0",
+  "uvicorn[standard]>=0.13.0"
+]
+optional-dependencies = {"image" = ["Pillow>=9.0.0"],"test" = ["coverage"], "image-similarity" = ["numpy>=1.21.0", "imagededup>=0.3.0"], "all" = ["Pillow>=9.0.0", "numpy>=1.21.0", "imagededup>=0.3.0"]}
+
+[project.urls]
+"Homepage" = "https://github.com/mahdikiani/fastapi-mongo-base-app"
+"Bug Reports" = "https://github.com/mahdikiani/fastapi-mongo-base-app/issues"
+"Funding" = "https://github.com/mahdikiani/fastapi-mongo-base-app"
+"Say Thanks!" = "https://saythanks.io/to/mahdikiani"
+"Source" = "https://github.com/mahdikiani/fastapi-mongo-base-app"
+
+[tool.setuptools]
+package-data = {"usso" = ["*.dat"]}

fastapi_mongo_base-0.8.30/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fastapi_mongo_base-0.8.30/src/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-0.8.30/src/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-0.8.30/src/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-0.8.30/src/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-0.8.30/src/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]