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

fastapi_mongo_base/schemas.py

@@ -0,0 +1,107 @@
+import uuid
+from datetime import datetime
+from enum import Enum
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel, Field
+
+try:
+    from server.config import Settings
+except ImportError:
+    from .core.config import Settings
+
+
+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 | None = None
+
+
+class BaseEntitySchema(CoreEntitySchema):
+    uid: uuid.UUID = Field(
+        default_factory=uuid.uuid4, json_schema_extra={"index": True, "unique": True}
+    )
+
+    @property
+    def item_url(self):
+        return f"https://{Settings.root_url}/{Settings.base_path}/{self.__class__.__name__.lower()}s/{self.uid}"
+
+    @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 []
+
+    @classmethod
+    def search_exclude_set(cls) -> list[str]:
+        return ["meta_data"]
+
+    @classmethod
+    def search_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/tasks.py

@@ -0,0 +1,291 @@
+import asyncio
+import logging
+import uuid
+from datetime import datetime
+from enum import Enum
+from typing import Any, Callable, Coroutine, Literal, Union
+
+import json_advanced as json
+from pydantic import BaseModel, Field, field_serializer, field_validator
+from singleton import Singleton
+
+from .schemas import BaseEntitySchema
+from .utils import aionetwork, basic
+
+
+class TaskStatusEnum(str, Enum):
+    none = "null"
+    draft = "draft"
+    init = "init"
+    processing = "processing"
+    paused = "paused"
+    completed = "completed"
+    done = "done"
+    error = "error"
+
+    @classmethod
+    def Finishes(cls):
+        return [cls.done, cls.error, cls.completed]
+
+    @property
+    def is_done(self):
+        return self in self.Finishes()
+
+
+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: TaskStatusEnum
+    duration: int = 0
+    log_type: str | None = None
+    # 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 TaskMixin(BaseModel):
+    task_status: TaskStatusEnum = TaskStatusEnum.draft
+    task_report: str | None = None
+    task_progress: int = -1
+    task_logs: list[TaskLogRecord] = []
+    task_references: TaskReferenceList | None = None
+    webhook_url: str | None = None
+
+    @property
+    def item_webhook_url(self):
+        return f"{self.item_url}/webhook"
+
+    @field_validator("task_status", mode="before")
+    def validate_task_status(cls, value):
+        if isinstance(value, str):
+            return TaskStatusEnum(value)
+        return value
+
+    @field_serializer("task_status")
+    def serialize_task_status(self, value):
+        if isinstance(value, TaskStatusEnum):
+            return value.value
+        return value
+
+    @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: "TaskMixin", *, sync=False, **kwargs):
+
+        async def webhook_call(*args, **kwargs):
+            try:
+                await aionetwork.aio_request(*args, **kwargs)
+            except Exception as e:
+                import traceback
+
+                traceback_str = "".join(traceback.format_tb(e.__traceback__))
+                await task_instance.save_report(
+                    f"An error occurred in webhook_call: {e}",
+                    emit=False,
+                    log_type="webhook_error",
+                )
+                await task_instance.save()
+                logging.error(
+                    "\n".join(
+                        ["An error occurred in webhook_call:", traceback_str, str(e)]
+                    )
+                )
+
+        def webhook_task(webhook_url: str):
+            return
+
+        signals = []
+        meta_data = getattr(task_instance, "meta_data") or {}
+        task_dict = task_instance.model_dump()
+        task_dict.update({"task_type": task_instance.__class__.__name__})
+        task_dict.update(kwargs)
+
+        for webhook_url in [
+            task_instance.webhook_url,
+            meta_data.get("webhook"),
+            meta_data.get("webhook_url"),
+        ]:
+            if not webhook_url:
+                continue
+            signals.append(
+                webhook_call(
+                    method="post",
+                    url=webhook_url,
+                    headers={"Content-Type": "application/json"},
+                    data=json.dumps(task_dict),
+                )
+            )
+
+        signals += [
+            (
+                signal(task_instance)
+                if asyncio.iscoroutinefunction(signal)
+                else asyncio.to_thread(signal, task_instance)
+            )
+            for signal in cls.signals()
+        ]
+
+        if not sync:
+            await asyncio.gather(*signals)
+            return
+
+        for signal in signals:
+            await signal
+
+    async def save_status(
+        self,
+        status: TaskStatusEnum,
+        **kwargs,
+    ):
+        self.task_status = status
+        await self.add_log(
+            TaskLogRecord(
+                task_status=self.task_status,
+                message=f"Status changed to {status}",
+                log_type=kwargs.get("log_type", "status_update"),
+            ),
+            **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}",
+                log_type=kwargs.get("log_type", "add_reference"),
+            ),
+            **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,
+                log_type=kwargs.get("log_type", "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()
+
+    @basic.try_except_wrapper
+    async def save_and_emit(self, **kwargs):
+        if kwargs.get("sync"):
+            await self.save()
+            await self.emit_signals(self, **kwargs)
+        else:
+            await asyncio.gather(self.save(), self.emit_signals(self, **kwargs))
+
+    async def update_and_emit(self, **kwargs):
+        if kwargs.get("task_status") in [
+            TaskStatusEnum.done,
+            TaskStatusEnum.error,
+            TaskStatusEnum.completed,
+        ]:
+            kwargs["task_progress"] = kwargs.get("task_progress", 100)
+            # kwargs["task_report"] = kwargs.get("task_report")
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+        if kwargs.get("task_report"):
+            await self.add_log(
+                TaskLogRecord(
+                    task_status=self.task_status,
+                    message=kwargs["task_report"],
+                    log_type=kwargs.get("log_type", "status_update"),
+                ),
+                emit=False,
+            )
+        await self.save_and_emit()

fastapi_mongo_base/utils/aionetwork.py

@@ -0,0 +1,90 @@
+import logging
+from io import BytesIO
+from typing import Literal
+
+import aiofiles
+import httpx
+
+
+async def prepare_url(url: str) -> str:
+    """Ensure the URL is valid and starts with http or https."""
+    if url is None:
+        raise ValueError("url is required")
+    return url if url.startswith("http") else f"https://{url}"
+
+
+async def log_error(url: str, status_code: int, text: str, **kwargs):
+    """Log request errors."""
+    data = kwargs.get("data")
+    if not isinstance(data, str):
+        data = str(data)
+
+    logging.error(f"Error in aio_request {url} {data[:100]}: {status_code} {text}")
+
+
+async def handle_binary_response(response: httpx.Response) -> BytesIO:
+    """Handle binary response."""
+    resp_bytes = BytesIO(await response.aread())
+    resp_bytes.seek(0)
+    return resp_bytes
+
+
+async def aio_request_client(
+    client: httpx.AsyncClient,
+    *,
+    method: str = "get",
+    url: str = None,
+    response_type: Literal["json", "binary", "text", "bytes"] = "json",
+    **kwargs,
+):
+    """Perform an HTTP request and return the desired response type."""
+    url = await prepare_url(url)
+
+    raise_exception = kwargs.pop("raise_exception", True)
+
+    response = await client.request(method, url, **kwargs)
+
+    try:
+        response.raise_for_status()
+    except Exception as e:
+        await log_error(url, response.status_code, response.text, **kwargs)
+        if raise_exception:
+            raise e
+
+    if response_type == "binary":
+        return await handle_binary_response(response)
+    if response_type == "bytes":
+        return response.content
+    if response_type == "json":
+        return response.json()
+    return response.text
+
+
+async def aio_request(*, method: str = "get", url: str = None, **kwargs) -> dict:
+    async with httpx.AsyncClient() as client:
+        return await aio_request_client(client, method=method, url=url, **kwargs)
+
+
+async def aio_request_binary(
+    *, method: str = "get", url: str = None, **kwargs
+) -> BytesIO:
+    return await aio_request(method=method, url=url, response_type="binary", **kwargs)
+
+
+async def aio_download(
+    url: str, filename: str, *, chunk_size: int = 8192, **kwargs
+) -> str:
+    """Download a file and save it locally."""
+    url = await prepare_url(url)
+    raise_exception = kwargs.pop("raise_exception", True)
+
+    async with httpx.AsyncClient() as client:
+        async with client.stream("GET", url, **kwargs) as response:
+            if raise_exception:
+                response.raise_for_status()
+
+            async with aiofiles.open(filename, "wb") as f:
+                async for chunk in response.aiter_bytes(chunk_size=chunk_size):
+                    await f.write(chunk)
+
+    return filename

fastapi_mongo_base/utils/basic.py

@@ -0,0 +1,75 @@
+import asyncio
+import functools
+import logging
+
+
+def get_all_subclasses(cls: type):
+    subclasses = cls.__subclasses__()
+    return subclasses + [
+        sub for subclass in subclasses for sub in get_all_subclasses(subclass)
+    ]
+
+
+def try_except_wrapper(func):
+    @functools.wraps(func)
+    async def wrapped_func(*args, **kwargs):
+        try:
+            if asyncio.iscoroutinefunction(func):
+                return await func(*args, **kwargs)
+            return await asyncio.to_thread(func, *args, **kwargs)
+        except Exception as e:
+            import inspect
+            import traceback
+
+            func_name = func.__name__
+            if len(args) > 0:
+                if inspect.ismethod(func) or inspect.isfunction(func):
+                    if hasattr(args[0], "__class__"):
+                        class_name = args[0].__class__.__name__
+                        func_name = f"{class_name}.{func_name}"
+
+            traceback_str = "".join(traceback.format_tb(e.__traceback__))
+            logging.error(f"An error occurred in {func_name}:\n{traceback_str}\n{e}")
+            return None
+
+    return wrapped_func
+
+
+def delay_execution(seconds):
+    def decorator(func):
+        @functools.wraps(func)
+        async def wrapped_func(*args, **kwargs):
+            await asyncio.sleep(seconds)
+            if asyncio.iscoroutinefunction(func):
+                return await func(*args, **kwargs)
+            return await asyncio.to_thread(func, *args, **kwargs)
+
+        return wrapped_func
+
+    return decorator
+
+
+def retry_execution(attempts, delay=0):
+    def decorator(func):
+        @functools.wraps(func)
+        async def wrapped_func(*args, **kwargs):
+            last_exception = None
+            for attempt in range(attempts):
+                try:
+                    if asyncio.iscoroutinefunction(func):
+                        return await func(*args, **kwargs)
+                    return await asyncio.to_thread(func, *args, **kwargs)
+                except Exception as e:
+                    last_exception = e
+                    logging.warning(
+                        f"Attempt {attempt + 1} failed for {func.__name__}: {e}"
+                    )
+                    if delay > 0 and attempt < attempts - 1:
+                        await asyncio.sleep(delay)
+            # If the loop finishes and the function didn't return successfully
+            logging.error(f"All {attempts} attempts failed for {func.__name__}")
+            raise last_exception
+
+        return wrapped_func
+
+    return decorator

fastapi_mongo_base/utils/bsontools.py

@@ -0,0 +1,25 @@
+import uuid
+from decimal import Decimal
+
+from bson import Binary
+from bson.decimal128 import Decimal128
+
+
+def decimal_amount(value):
+    if type(value) == Decimal128:
+        return Decimal(value.to_decimal())
+    return value
+
+
+def get_bson_value(value):
+    if isinstance(value, Decimal):
+        return Decimal128(value)
+    if isinstance(value, bytes):
+        return Binary(value)
+    if isinstance(value, uuid.UUID):
+        return Binary.from_uuid(value)
+    if isinstance(value, dict):
+        return {k: get_bson_value(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [get_bson_value(v) for v in value]
+    return value