fastapi-mongo-base 0.2.0__tar.gz

fastapi_mongo_base-0.2.0/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.2.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: fastapi-mongo-base
+Version: 0.2.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>
+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: peppercorn
+Requires-Dist: pydantic>=1.8.2
+Requires-Dist: requests>=2.26.0
+Requires-Dist: pyjwt[crypto]
+Requires-Dist: singleton_package
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.65.0; extra == "fastapi"
+Requires-Dist: uvicorn[standard]>=0.13.0; extra == "fastapi"
+Provides-Extra: django
+Requires-Dist: Django>=3.2; extra == "django"
+Provides-Extra: dev
+Requires-Dist: check-manifest; extra == "dev"
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+
+# 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.2.0/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.2.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fastapi-mongo-base"
+version = "0.2.0"
+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 = [
+  "peppercorn",  # Example main dependency
+  "pydantic>=1.8.2",
+  "requests>=2.26.0",
+  "pyjwt[crypto]",
+  "singleton_package"
+]
+optional-dependencies = {"fastapi" = ["fastapi>=0.65.0", "uvicorn[standard]>=0.13.0"],"django" = ["Django>=3.2"],"dev" = ["check-manifest"],"test" = ["coverage"]}
+
+[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.2.0/setup.cfg

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

fastapi_mongo_base-0.2.0/src/fastapi-mongo-base/handlers.py

@@ -0,0 +1,80 @@
+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
+
+
+# def update_dto(cls: OT):
+#     async def dto(request: Request, user: UserData = None, **kwargs):
+#         uid = request.path_params["uid"]
+#         form_data = await request.json()
+#         kwargs = {}
+#         if user:
+#             kwargs["user"] = user
+#         item = await cls.get_item(uid, **kwargs)
+
+#         if not item:
+#             raise BaseHTTPException(
+#                 status_code=404,
+#                 error="item_not_found",
+#                 message="Item not found",
+#             )
+
+#         item_data = item.model_dump() | form_data
+
+#         return cls(**item_data)
+
+#     return dto
+
+
+# def update_dto(cls: Type[OT]) -> Callable:
+#     async def dto(
+#         request: Request, item: OT, user: Optional[UserData] = None, **kwargs
+#     ) -> OT:
+#         # request.path_params["uid"]
+#         form_data = await request.json()
+#         # kwargs = {}
+#         # if user:
+#         #     kwargs["user_id"] = user.uid
+
+#         for key, value in form_data.items():
+#             setattr(item, key, value)
+
+#         return item
+
+#     return dto

fastapi_mongo_base-0.2.0/src/fastapi-mongo-base/models.py

@@ -0,0 +1,275 @@
+import uuid
+from datetime import datetime
+
+from .schemas import (
+    BaseEntitySchema,
+    BusinessEntitySchema,
+    BusinessOwnedEntitySchema,
+    OwnedEntitySchema,
+)
+from beanie import Document, Insert, Replace, Save, SaveChanges, Update, before_event
+from pydantic import ConfigDict
+from pymongo import ASCENDING, IndexModel
+from server.config import Settings
+
+from .tasks import TaskMixin
+
+
+class BaseEntity(BaseEntitySchema, Document):
+    class Settings:
+        __abstract__ = True
+
+        keep_nulls = False
+        validate_on_save = True
+
+        indexes = [
+            IndexModel([("uid", ASCENDING)], unique=True),
+        ]
+
+    @before_event([Insert, Replace, Save, SaveChanges, Update])
+    async def pre_save(self):
+        self.updated_at = datetime.now()
+
+    @classmethod
+    def get_query(
+        cls,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        is_deleted: bool = False,
+        *args,
+        **kwargs,
+    ):
+        base_query = [cls.is_deleted == is_deleted]
+        if hasattr(cls, "user_id") and user_id:
+            base_query.append(cls.user_id == user_id)
+        if hasattr(cls, "business_name"):
+            base_query.append(cls.business_name == business_name)
+
+        query = cls.find(*base_query)
+        return query
+
+    @classmethod
+    async def get_item(
+        cls,
+        uid,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        is_deleted: bool = False,
+        *args,
+        **kwargs,
+    ) -> "BaseEntity":
+        query = cls.get_query(
+            user_id=user_id,
+            business_name=business_name,
+            is_deleted=is_deleted,
+            *args,
+            **kwargs,
+        ).find(cls.uid == uid)
+        items = await query.to_list()
+        if not items:
+            return None
+        if len(items) > 1:
+            raise ValueError("Multiple items found")
+        return items[0]
+
+    @classmethod
+    def adjust_pagination(cls, offset: int, limit: int):
+        offset = max(offset or 0, 0)
+        limit = max(1, min(limit or 10, Settings.page_max_limit))
+        return offset, limit
+
+    @classmethod
+    async def list_items(
+        cls,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        offset: int = 0,
+        limit: int = 10,
+        is_deleted: bool = False,
+        *args,
+        **kwargs,
+    ):
+        offset, limit = cls.adjust_pagination(offset, limit)
+
+        query = cls.get_query(
+            user_id=user_id,
+            business_name=business_name,
+            is_deleted=is_deleted,
+            *args,
+            **kwargs,
+        )
+
+        items_query = query.sort("-created_at").skip(offset).limit(limit)
+        items = await items_query.to_list()
+        return items
+
+    @classmethod
+    async def total_count(
+        cls,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        is_deleted: bool = False,
+        *args,
+        **kwargs,
+    ):
+        query = cls.get_query(
+            user_id=user_id,
+            business_name=business_name,
+            is_deleted=is_deleted,
+            *args,
+            **kwargs,
+        )
+        return await query.count()
+
+    @classmethod
+    async def list_total_combined(
+        cls,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        offset: int = 0,
+        limit: int = 10,
+        is_deleted: bool = False,
+        *args,
+        **kwargs,
+    ) -> tuple[list["BaseEntity"], int]:
+        offset, limit = cls.adjust_pagination(offset, limit)
+
+        query = cls.get_query(
+            user_id=user_id,
+            business_name=business_name,
+            is_deleted=is_deleted,
+            *args,
+            **kwargs,
+        )
+        items_query = query.sort("-created_at").skip(offset).limit(limit)
+        items = await items_query.to_list()
+        total = await query.count()
+
+        return items, total
+
+    @classmethod
+    async def create_item(cls, data: dict):
+        # for key in data.keys():
+        #     if cls.create_exclude_set() and key not in cls.create_field_set():
+        #         data.pop(key, None)
+        #     elif cls.create_exclude_set() and key in cls.create_exclude_set():
+        #         data.pop(key, None)
+
+        item = cls(**data)
+        await item.save()
+        return item
+
+    @classmethod
+    async def update_item(cls, item: "BaseEntity", data: dict):
+        for key, value in data.items():
+            if cls.update_field_set() and key not in cls.update_field_set():
+                continue
+            if cls.update_exclude_set() and key in cls.update_exclude_set():
+                continue
+
+            setattr(item, key, value)
+
+        await item.save()
+        return item
+
+    @classmethod
+    async def delete_item(cls, item: "BaseEntity"):
+        item.is_deleted = True
+        await item.save()
+        return item
+
+
+class OwnedEntity(OwnedEntitySchema, BaseEntity):
+
+    class Settings(BaseEntity.Settings):
+        __abstract__ = True
+
+        indexes = BaseEntity.Settings.indexes + [IndexModel([("user_id", ASCENDING)])]
+
+    @classmethod
+    async def get_item(cls, uid, user_id, *args, **kwargs) -> "OwnedEntity":
+        if user_id == None:
+            raise ValueError("user_id is required")
+        return await super().get_item(uid, user_id=user_id, *args, **kwargs)
+
+
+class BusinessEntity(BusinessEntitySchema, BaseEntity):
+
+    class Settings(BaseEntity.Settings):
+        __abstract__ = True
+
+        indexes = BaseEntity.Settings.indexes + [
+            IndexModel([("business_name", ASCENDING)])
+        ]
+
+    @classmethod
+    async def get_item(cls, uid, business_name, *args, **kwargs) -> "BusinessEntity":
+        if business_name == None:
+            raise ValueError("business_name is required")
+        return await super().get_item(uid, business_name=business_name, *args, **kwargs)
+
+    async def get_business(self):
+        raise NotImplementedError
+        from apps.business_mongo.models import Business
+
+        return await Business.get_by_name(self.business_name)
+
+
+class BusinessOwnedEntity(BusinessOwnedEntitySchema, BaseEntity):
+
+    class Settings(BusinessEntity.Settings):
+        __abstract__ = True
+
+        indexes = BusinessEntity.Settings.indexes + [
+            IndexModel([("user_id", ASCENDING)])
+        ]
+
+    @classmethod
+    async def get_item(
+        cls, uid, business_name, user_id, *args, **kwargs
+    ) -> "BusinessOwnedEntity":
+        if business_name == None:
+            raise ValueError("business_name is required")
+        # if user_id == None:
+        #     raise ValueError("user_id is required")
+        return await super().get_item(
+            uid, business_name=business_name, user_id=user_id, *args, **kwargs
+        )
+
+
+class BaseEntityTaskMixin(BaseEntity, TaskMixin):
+    class Settings(BaseEntity.Settings):
+        __abstract__ = True
+
+
+class ImmutableBase(BaseEntity):
+    model_config = ConfigDict(frozen=True)
+
+    class Settings(BaseEntity.Settings):
+        __abstract__ = True
+
+    @classmethod
+    async def update_item(cls, item: "BaseEntity", data: dict):
+        raise ValueError("Immutable items cannot be updated")
+
+    @classmethod
+    async def delete_item(cls, item: "BaseEntity"):
+        raise ValueError("Immutable items cannot be deleted")
+
+
+class ImmutableOwnedEntity(ImmutableBase, OwnedEntity):
+
+    class Settings(OwnedEntity.Settings):
+        __abstract__ = True
+
+
+class ImmutableBusinessEntity(ImmutableBase, BusinessEntity):
+
+    class Settings(BusinessEntity.Settings):
+        __abstract__ = True
+
+
+class ImmutableBusinessOwnedEntity(ImmutableBase, BusinessOwnedEntity):
+
+    class Settings(BusinessOwnedEntity.Settings):
+        __abstract__ = True

fastapi_mongo_base-0.2.0/src/fastapi-mongo-base/routes.py

@@ -0,0 +1,239 @@
+import uuid
+from typing import Any, Generic, Type, TypeVar
+
+import singleton
+from .handlers import create_dto
+from .schemas import BaseEntitySchema, PaginatedResponse
+from core.exceptions import BaseHTTPException
+from fastapi import APIRouter, BackgroundTasks, Query, Request
+from server.config import Settings
+
+from .models import BaseEntity, BaseEntityTaskMixin
+
+# Define a type variable
+T = TypeVar("T", bound=BaseEntity)
+TE = TypeVar("TE", bound=BaseEntityTaskMixin)
+TS = TypeVar("TS", bound=BaseEntitySchema)
+
+
+class AbstractBaseRouter(Generic[T, TS], metaclass=singleton.Singleton):
+
+    def __init__(
+        self,
+        model: Type[T],
+        user_dependency: Any,
+        *args,
+        prefix: str = None,
+        tags: list[str] = None,
+        schema: Type[TS] = None,
+        **kwargs,
+    ):
+        self.model = model
+        if schema is None:
+            schema = self.model
+        self.schema = schema
+        self.user_dependency = user_dependency
+        if prefix is None:
+            prefix = f"/{self.model.__name__.lower()}s"
+        if tags is None:
+            tags = [self.model.__name__]
+        self.router = APIRouter(prefix=prefix, tags=tags, **kwargs)
+
+        self.config_schemas(self.schema, **kwargs)
+        self.config_routes(**kwargs)
+
+    @classmethod
+    def config_schemas(cls, schema, **kwargs):
+        cls.list_response_schema = PaginatedResponse[schema]
+        cls.list_item_schema = schema
+        cls.retrieve_response_schema = schema
+        cls.create_response_schema = schema
+        cls.update_response_schema = schema
+        cls.delete_response_schema = schema
+
+        cls.create_request_schema = schema
+        cls.update_request_schema = schema
+
+    def config_routes(self, **kwargs):
+        self.router.add_api_route(
+            "/",
+            self.list_items,
+            methods=["GET"],
+            response_model=self.list_response_schema,
+            status_code=200,
+        )
+        self.router.add_api_route(
+            "/{uid:uuid}",
+            self.retrieve_item,
+            methods=["GET"],
+            response_model=self.retrieve_response_schema,
+            status_code=200,
+        )
+        self.router.add_api_route(
+            "/",
+            self.create_item,
+            methods=["POST"],
+            response_model=self.create_response_schema,
+            status_code=201,
+        )
+        self.router.add_api_route(
+            "/{uid:uuid}",
+            self.update_item,
+            methods=["PATCH"],
+            response_model=self.update_response_schema,
+            status_code=200,
+        )
+        self.router.add_api_route(
+            "/{uid:uuid}",
+            self.delete_item,
+            methods=["DELETE"],
+            response_model=self.delete_response_schema,
+            # status_code=204,
+        )
+
+    async def get_item(
+        self,
+        uid: uuid.UUID,
+        user_id: uuid.UUID = None,
+        business_name: str = None,
+        **kwargs,
+    ):
+        item = await self.model.get_item(
+            uid, user_id=user_id, business_name=business_name, **kwargs
+        )
+        if item is None:
+            raise BaseHTTPException(
+                status_code=404,
+                error="item_not_found",
+                message=f"{self.model.__name__.capitalize()} not found",
+            )
+        return item
+
+    async def get_user(self, request: Request, *args, **kwargs):
+        if self.user_dependency is None:
+            return None
+        return await self.user_dependency(request)
+
+    async def get_user_id(self, request: Request, *args, **kwargs):
+        user = await self.get_user(request)
+        user_id = user.uid if user else None
+        return user_id
+
+    async def list_items(
+        self,
+        request: Request,
+        offset: int = Query(0, ge=0),
+        limit: int = Query(10, ge=1, le=Settings.page_max_limit),
+    ):
+        user_id = await self.get_user_id(request)
+        limit = max(1, min(limit, Settings.page_max_limit))
+
+        items, total = await self.model.list_total_combined(
+            user_id=user_id, offset=offset, limit=limit
+        )
+        items_in_schema = [self.list_item_schema(**item.model_dump()) for item in items]
+
+        return PaginatedResponse(
+            items=items_in_schema,
+            total=total,
+            offset=offset,
+            limit=limit,
+        )
+
+    async def retrieve_item(
+        self,
+        request: Request,
+        uid: uuid.UUID,
+    ):
+        user_id = await self.get_user_id(request)
+        item = await self.get_item(uid, user_id=user_id)
+        return item
+
+    async def create_item(
+        self,
+        request: Request,
+        data: dict,
+    ):
+        user_id = await self.get_user_id(request)
+        item_data: TS = await create_dto(self.create_response_schema)(
+            request, user_id=user_id
+        )
+        item = await self.model.create_item(item_data.model_dump())
+        # item: T = await create_dto(self.create_request_schema)(request, user)
+        await item.save()
+        return item
+
+    async def update_item(
+        self,
+        request: Request,
+        uid: uuid.UUID,
+        data: dict,
+    ):
+        user_id = await self.get_user_id(request)
+        item = await self.get_item(uid, user_id=user_id)
+        # item = await update_dto(self.model)(request, user)
+        item = await self.model.update_item(item, data)
+        return item
+
+    async def delete_item(
+        self,
+        request: Request,
+        uid: uuid.UUID,
+    ):
+        user_id = await self.get_user_id(request)
+        item = await self.get_item(uid, user_id=user_id)
+
+        item = await self.model.delete_item(item)
+        return item
+
+
+class AbstractTaskRouter(AbstractBaseRouter[TE, TS]):
+    def __init__(
+        self, model: Type[TE], user_dependency: Any, schema: TS, *args, **kwargs
+    ):
+        super().__init__(model, user_dependency, schema=schema, *args, **kwargs)
+        self.router.add_api_route(
+            "/{uid:uuid}/start",
+            self.start_item,
+            methods=["POST"],
+            response_model=self.retrieve_response_schema,
+        )
+
+    async def start_item(
+        self, request: Request, uid: uuid.UUID, background_tasks: BackgroundTasks
+    ):
+        user_id = await self.get_user_id(request)
+        item: TE = await self.get_item(uid, user_id=user_id)
+        background_tasks.add_task(item.start_processing)
+        return item.model_dump()
+
+
+def copy_router(router: APIRouter, new_prefix: str):
+    new_router = APIRouter(prefix=new_prefix)
+    for route in router.routes:
+        new_router.add_api_route(
+            route.path.replace(router.prefix, ""),
+            route.endpoint,
+            methods=[
+                method
+                for method in route.methods
+                if method in ["GET", "POST", "PUT", "DELETE", "PATCH"]
+            ],
+            name=route.name,
+            response_class=route.response_class,
+            status_code=route.status_code,
+            tags=route.tags,
+            dependencies=route.dependencies,
+            summary=route.summary,
+            description=route.description,
+            response_description=route.response_description,
+            responses=route.responses,
+            deprecated=route.deprecated,
+            include_in_schema=route.include_in_schema,
+            response_model=route.response_model,
+            response_model_include=route.response_model_include,
+            response_model_exclude=route.response_model_exclude,
+            response_model_by_alias=route.response_model_by_alias,
+        )
+
+    return new_router

fastapi_mongo_base-0.2.0/src/fastapi-mongo-base/schemas.py

@@ -0,0 +1,90 @@
+import uuid
+from datetime import datetime
+from enum import Enum
+from typing import Any, Generic, TypeVar
+
+from pydantic import BaseModel, Field
+
+
+class CoreEntitySchema(BaseModel):
+    created_at: datetime = Field(
+        default_factory=datetime.now, json_schema_extra={"index": True}
+    )
+    updated_at: datetime = Field(default_factory=datetime.now)
+    is_deleted: bool = False
+    meta_data: dict[str, Any] | None = None
+
+
+class BaseEntitySchema(CoreEntitySchema):
+    uid: uuid.UUID = Field(
+        default_factory=uuid.uuid4, json_schema_extra={"index": True, "unique": True}
+    )
+
+    @classmethod
+    def create_exclude_set(cls) -> list[str]:
+        return ["uid", "created_at", "updated_at", "is_deleted"]
+
+    @classmethod
+    def create_field_set(cls) -> list:
+        return []
+
+    @classmethod
+    def update_exclude_set(cls) -> list:
+        return ["uid", "created_at", "updated_at"]
+
+    @classmethod
+    def update_field_set(cls) -> list:
+        return []
+
+    def expired(self, days: int = 3):
+        return (datetime.now() - self.updated_at).days > days
+
+
+class OwnedEntitySchema(BaseEntitySchema):
+    user_id: uuid.UUID
+
+    @classmethod
+    def create_exclude_set(cls) -> list[str]:
+        return super().create_exclude_set() + ["user_id"]
+
+    @classmethod
+    def update_exclude_set(cls) -> list[str]:
+        return super().update_exclude_set() + ["user_id"]
+
+
+class BusinessEntitySchema(BaseEntitySchema):
+    business_name: str
+
+    @classmethod
+    def create_exclude_set(cls) -> list[str]:
+        return super().create_exclude_set() + ["business_name"]
+
+    @classmethod
+    def update_exclude_set(cls) -> list[str]:
+        return super().update_exclude_set() + ["business_name"]
+
+
+class BusinessOwnedEntitySchema(OwnedEntitySchema, BusinessEntitySchema):
+
+    @classmethod
+    def create_exclude_set(cls) -> list[str]:
+        return list(set(super().create_exclude_set() + ["business_name", "user_id"]))
+
+    @classmethod
+    def update_exclude_set(cls) -> list[str]:
+        return list(set(super().update_exclude_set() + ["business_name", "user_id"]))
+
+
+class Language(str, Enum):
+    English = "English"
+    Persian = "Persian"
+
+
+T = TypeVar("T", bound=BaseEntitySchema)
+
+
+class PaginatedResponse(BaseModel, Generic[T]):
+    items: list[T]
+    total: int
+    offset: int
+    limit: int

fastapi_mongo_base-0.2.0/src/fastapi-mongo-base/tasks.py

@@ -0,0 +1,197 @@
+import asyncio
+import logging
+import uuid
+from datetime import datetime
+from enum import Enum
+from typing import Any, Callable, Coroutine, Literal, Union
+
+from .schemas import BaseEntitySchema
+from pydantic import BaseModel, Field
+from singleton import Singleton
+from utils import aionetwork, basic
+
+
+class SignalRegistry(metaclass=Singleton):
+    def __init__(self):
+        self.signal_map: dict[
+            str,
+            list[Callable[..., None] | Callable[..., Coroutine[Any, Any, None]]],
+        ] = {}
+
+
+class TaskLogRecord(BaseModel):
+    reported_at: datetime = Field(default_factory=datetime.now)
+    message: str
+    task_status: Literal["draft", "init", "processing", "completed", "error"]
+    duration: int = 0
+    data: dict | None = None
+
+    def __eq__(self, other):
+        if isinstance(other, TaskLogRecord):
+            return (
+                self.reported_at == other.reported_at
+                and self.message == other.message
+                and self.task_status == other.task_status
+                and self.duration == other.duration
+                and self.data == other.data
+            )
+        return False
+
+    def __hash__(self):
+        return hash((self.reported_at, self.message, self.task_status, self.duration))
+
+
+class TaskReference(BaseModel):
+    task_id: uuid.UUID
+    task_type: str
+
+    def __eq__(self, other):
+        if isinstance(other, TaskReference):
+            return self.task_id == other.task_id and self.task_type == other.task_type
+        return False
+
+    def __hash__(self):
+        return hash((self.task_id, self.task_type))
+
+    async def get_task_item(self) -> BaseEntitySchema | None:
+        task_classes = {
+            subclass.__name__: subclass
+            for subclass in basic.get_all_subclasses(TaskMixin)
+            if issubclass(subclass, BaseEntitySchema)
+        }
+        # task_classes = self._get_all_task_classes()
+
+        task_class = task_classes.get(self.task_type)
+        if not task_class:
+            raise ValueError(f"Task type {self.task_type} is not supported.")
+
+        task_item = await task_class.find_one(task_class.uid == self.task_id)
+        if not task_item:
+            raise ValueError(
+                f"No task found with id {self.task_id} of type {self.task_type}."
+            )
+
+        return task_item
+
+
+class TaskReferenceList(BaseModel):
+    tasks: list[Union[TaskReference, "TaskReferenceList"]] = []
+    mode: Literal["serial", "parallel"] = "serial"
+
+    async def list_processing(self):
+        task_items = [task.get_task_item() for task in self.tasks]
+        match self.mode:
+            case "serial":
+                for task_item in task_items:
+                    await task_item.start_processing()
+            case "parallel":
+                await asyncio.gather(*[task.start_processing() for task in task_items])
+
+
+class TaskStatusEnum(str, Enum):
+    draft = "draft"
+    init = "init"
+    processing = "processing"
+    completed = "completed"
+    error = "error"
+
+
+class TaskMixin(BaseModel):
+    task_status: Literal["draft", "init", "processing", "completed", "error"] = "draft"
+    task_report: str | None = None
+    task_progress: int = -1
+    task_logs: list[TaskLogRecord] = []
+    task_references: TaskReferenceList | None = None
+
+    @classmethod
+    def signals(cls):
+        registry = SignalRegistry()
+        if cls.__name__ not in registry.signal_map:
+            registry.signal_map[cls.__name__] = []
+        return registry.signal_map[cls.__name__]
+
+    @classmethod
+    def add_signal(
+        cls,
+        signal: Callable[..., None] | Callable[..., Coroutine[Any, Any, None]],
+    ):
+        cls.signals().append(signal)
+
+    @classmethod
+    async def emit_signals(cls, task_instance, **kwargs):
+        if task_instance.meta_data:
+            webhook = task_instance.meta_data.get(
+                "webhook"
+            ) or task_instance.meta_data.get("webhook_url")
+            webhook_signals = [
+                aionetwork.aio_request(
+                    method="post",
+                    url=webhook,
+                    data=task_instance.model_dump_json(),
+                )
+            ]
+        else:
+            webhook_signals = []
+
+        signals = webhook_signals + [
+            (
+                signal(task_instance)
+                if asyncio.iscoroutinefunction(signal)
+                else asyncio.to_thread(signal, task_instance)
+            )
+            for signal in cls.signals()
+        ]
+
+        await asyncio.gather(*signals)
+
+    async def save_status(
+        self,
+        status: Literal["draft", "init", "processing", "done", "error"],
+        **kwargs,
+    ):
+        self.task_status = status
+        await self.add_log(
+            TaskLogRecord(
+                task_status=self.task_status,
+                message=f"Status changed to {status}",
+            ),
+            **kwargs,
+        )
+
+    async def add_reference(self, task_id: uuid.UUID, **kwargs):
+        self.task_references.append(task_id)
+        await self.add_log(
+            TaskLogRecord(
+                task_status=self.task_status,
+                message=f"Added reference to task {task_id}",
+            ),
+            **kwargs,
+        )
+
+    async def save_report(self, report: str, **kwargs):
+        self.task_report = report
+        await self.add_log(
+            TaskLogRecord(
+                task_status=self.task_status,
+                message=report,
+            ),
+            **kwargs,
+        )
+
+    async def add_log(self, log_record: TaskLogRecord, *, emit: bool = True, **kwargs):
+        self.task_logs.append(log_record)
+        if emit:
+            # await self.emit_signals(self)
+            await self.save_and_emit()
+
+    async def start_processing(self):
+        if self.task_references is None:
+            raise NotImplementedError("Subclasses should implement this method")
+
+        await self.task_references.list_processing()
+
+    async def save_and_emit(self):
+        try:
+            await asyncio.gather(self.save(), self.emit_signals(self))
+        except Exception as e:
+            logging.error(f"An error occurred: {e}")

fastapi_mongo_base-0.2.0/src/fastapi_mongo_base.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: fastapi-mongo-base
+Version: 0.2.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>
+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: peppercorn
+Requires-Dist: pydantic>=1.8.2
+Requires-Dist: requests>=2.26.0
+Requires-Dist: pyjwt[crypto]
+Requires-Dist: singleton_package
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.65.0; extra == "fastapi"
+Requires-Dist: uvicorn[standard]>=0.13.0; extra == "fastapi"
+Provides-Extra: django
+Requires-Dist: Django>=3.2; extra == "django"
+Provides-Extra: dev
+Requires-Dist: check-manifest; extra == "dev"
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+
+# 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.2.0/src/fastapi_mongo_base.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE.txt
+README.md
+pyproject.toml
+src/fastapi-mongo-base/__init__.py
+src/fastapi-mongo-base/handlers.py
+src/fastapi-mongo-base/models.py
+src/fastapi-mongo-base/routes.py
+src/fastapi-mongo-base/schemas.py
+src/fastapi-mongo-base/tasks.py
+src/fastapi_mongo_base.egg-info/PKG-INFO
+src/fastapi_mongo_base.egg-info/SOURCES.txt
+src/fastapi_mongo_base.egg-info/dependency_links.txt
+src/fastapi_mongo_base.egg-info/requires.txt
+src/fastapi_mongo_base.egg-info/top_level.txt
+tests/test_api.py
+tests/test_core.py
+tests/test_simple.py

fastapi_mongo_base-0.2.0/src/fastapi_mongo_base.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fastapi_mongo_base-0.2.0/src/fastapi_mongo_base.egg-info/requires.txt

@@ -0,0 +1,18 @@
+peppercorn
+pydantic>=1.8.2
+requests>=2.26.0
+pyjwt[crypto]
+singleton_package
+
+[dev]
+check-manifest
+
+[django]
+Django>=3.2
+
+[fastapi]
+fastapi>=0.65.0
+uvicorn[standard]>=0.13.0
+
+[test]
+coverage

fastapi_mongo_base-0.2.0/src/fastapi_mongo_base.egg-info/top_level.txt

@@ -0,0 +1 @@
+fastapi-mongo-base

fastapi_mongo_base-0.2.0/tests/test_api.py

@@ -0,0 +1,61 @@
+import os
+import unittest
+
+from usso.api import UssoAPI
+from usso.core import UserData
+
+
+class TestAPI(unittest.TestCase):
+    def get_usso(self):
+        return UssoAPI(
+            url="https://sso.usso.io",
+            api_key=os.getenv("USSO_API_KEY"),
+        )
+
+    def test_get_users(self):
+        usso_api = self.get_usso()
+        users = usso_api.get_users()
+        self.assertIsInstance(users, list)
+        for user in users:
+            self.assertIsInstance(user, UserData)
+
+    def test_get_user(self):
+        usso_api = self.get_usso()
+        users = usso_api.get_users()
+        if len(users) == 0:
+            self.skipTest("No users found")
+        user = users[0]
+        usso_api = self.get_usso()
+        user = usso_api.get_user(user.user_id)
+        self.assertIsInstance(user, UserData)
+
+    def test_get_user_by_credentials(self):
+        usso_api = self.get_usso()
+        users = usso_api._request(endpoint="website/users")
+        if len(users) == 0:
+            self.skipTest("No users found")
+        for user in users:
+            for auth in user["authenticators"]:
+                cred = {
+                    "auth_method": auth["auth_method"],
+                    "representor": auth["representor"],
+                }
+                user = usso_api.get_user_by_credentials(cred)
+                self.assertIsInstance(user, UserData)
+
+    def test_create_user_by_credentials(self):
+        import requests
+
+        usso_api = self.get_usso()
+        telegram_id = os.getenv("TELEGRAM_ID")
+        cred = {"auth_method": "telegram", "representor": telegram_id}
+        try:
+            usso_api.create_user_by_credentials(credentials=cred)
+        except requests.HTTPError as e:
+            if e.response.status_code == 400:
+                if e.response.json().get("error") == "already_exists":
+                    self.skipTest("Credential already exists")
+
+
+if __name__ == "__main__":
+    unittest.main()

fastapi_mongo_base-0.2.0/tests/test_core.py

@@ -0,0 +1,81 @@
+import unittest
+import uuid
+
+from usso.core import Usso
+from usso.exceptions import USSOException
+
+
+def generate_expired_token():
+    # Your code to generate an expired token goes here
+    pass
+
+
+# Generate an invalid token for testing
+def generate_invalid_token():
+    # Your code to generate an invalid token goes here
+    pass
+
+
+# Generate a valid token for testing
+def generate_valid_token():
+    # Your code to generate a valid token goes here
+    pass
+
+
+class TestCore(unittest.TestCase):
+    def test_user_data_from_token_valid_token(self):
+        return
+        # Generate a valid token for testing
+        valid_token = generate_valid_token()
+
+        # Call the user_data_from_token function with the valid token
+        user_data = Usso().user_data_from_token(valid_token)
+
+        # Assert that the user_data is not None
+        self.assertIsNotNone(user_data)
+
+        # Assert that the user_data has the expected attributes
+        self.assertEqual(user_data.uid, uuid.UUID(""))
+        self.assertEqual(user_data.token, valid_token)
+        # Add more assertions for other attributes
+        # Generate an expired token for testing
+
+    def test_user_data_from_token_expired_token(self):
+        return
+
+        # Generate an expired token for testing
+        expired_token = generate_expired_token()
+
+        # Call the user_data_from_token function with the expired token
+        user_data = Usso().user_data_from_token(expired_token)
+
+        # Assert that the user_data is None
+        self.assertIsNone(user_data)
+
+        # Assert that the USSOException is raised with the expected error
+        with self.assertRaises(USSOException) as context:
+            Usso().user_data_from_token(expired_token, raise_exception=True)
+        self.assertEqual(context.exception.error, "expired_signature")
+
+    def test_user_data_from_token_invalid_token(self):
+        return
+
+        # Generate an invalid token for testing
+        invalid_token = generate_invalid_token()
+
+        # Call the user_data_from_token function with the invalid token
+        user_data = Usso().user_data_from_token(invalid_token)
+
+        # Assert that the user_data is None
+        self.assertIsNone(user_data)
+
+        # Assert that the USSOException is raised with the expected error
+        with self.assertRaises(USSOException) as context:
+            Usso().user_data_from_token(invalid_token, raise_exception=True)
+        self.assertEqual(context.exception.error, "invalid_signature")
+
+    # Add more test cases for other scenarios
+
+
+if __name__ == "__main__":
+    unittest.main()

fastapi_mongo_base-0.2.0/tests/test_simple.py

@@ -0,0 +1,17 @@
+# the inclusion of the tests module is not meant to offer best practices for
+# testing in general, but rather to support the `find_packages` example in
+# setup.py that excludes installing the "tests" package
+
+import unittest
+
+
+class TestSimple(unittest.TestCase):
+    def test_import(self):
+        import usso
+
+        usso.Usso()
+        usso.UserData(user_id="123")
+
+
+if __name__ == "__main__":
+    unittest.main()