fastloom 0.3.3__tar.gz

fastloom-0.3.3/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.3
+Name: fastloom
+Version: 0.3.3
+Summary: Core package
+Requires-Python: >=3.12,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: celery
+Provides-Extra: dev
+Provides-Extra: fastapi
+Provides-Extra: httpx
+Provides-Extra: mongodb
+Provides-Extra: openai
+Provides-Extra: rabbit
+Provides-Extra: redis
+Provides-Extra: requests
+Requires-Dist: babel (>=2.17.0,<3.0.0)
+Requires-Dist: beanie (>=2.0.0,<3.0.0) ; extra == "mongodb"
+Requires-Dist: celery (>=5.5.3,<6.0.0) ; extra == "celery"
+Requires-Dist: fastapi (>=0,<1) ; extra == "fastapi" or extra == "rabbit"
+Requires-Dist: faststream[otel,rabbit] (>=0.5.28,<0.6.0) ; extra == "rabbit"
+Requires-Dist: httpx (>=0.28.0,<0.29.0) ; extra == "httpx"
+Requires-Dist: ipykernel (>=6.30.0,<7.0.0) ; extra == "dev"
+Requires-Dist: jdatetime (>=4.1.1,<5.0.0)
+Requires-Dist: jinja2 (>=3.1.6,<4.0.0)
+Requires-Dist: logfire[asgi,celery,fastapi,httpx,openai,pymongo,redis,requests,system-metrics] (>=4.0.0,<5.0.0)
+Requires-Dist: mypy (>=1.17.0,<2.0.0) ; extra == "dev"
+Requires-Dist: openai (>=1,<2) ; extra == "openai"
+Requires-Dist: opentelemetry-distro
+Requires-Dist: opentelemetry-exporter-otlp
+Requires-Dist: opentelemetry-instrumentation-aio-pika ; extra == "rabbit"
+Requires-Dist: orjson (==3.10.14)
+Requires-Dist: pre-commit (>=4.2.0,<5.0.0) ; extra == "dev"
+Requires-Dist: pydantic[email] (>=2.11,<3.0)
+Requires-Dist: python-jose (>=3.5.0,<4.0.0)
+Requires-Dist: python-multipart ; extra == "fastapi"
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: redis-om (>=1.0.3b,<2.0.0) ; extra == "redis"
+Requires-Dist: requests (>=2.32.0,<3.0.0) ; extra == "requests"
+Requires-Dist: ruff (>=0.12.5,<0.13.0) ; extra == "dev"
+Requires-Dist: sentry-sdk[fastapi] (>=2.0.0,<3.0.0)
+Requires-Dist: uvicorn (>=0.35.0,<0.36.0) ; extra == "fastapi" or extra == "rabbit"
+Description-Content-Type: text/markdown
+
+# Core bluprint Core Package
+## Install on other projects
+1. Run `poetry config http-basic.microservice-registry <your username> <your personal token>`
+
+## Committing updates
+1. Run `poetry version --next-phase patch`
+

fastloom-0.3.3/README.md

@@ -0,0 +1,6 @@
+# Core bluprint Core Package
+## Install on other projects
+1. Run `poetry config http-basic.microservice-registry <your username> <your personal token>`
+
+## Committing updates
+1. Run `poetry version --next-phase patch`

fastloom-0.3.3/fastloom/auth/__init__.py

@@ -0,0 +1,5 @@
+from contextvars import ContextVar
+
+from fastloom.auth.schemas import UserClaims
+
+Claims: ContextVar[UserClaims] = ContextVar("claims")

fastloom-0.3.3/fastloom/auth/depends.py

@@ -0,0 +1,58 @@
+from collections.abc import Callable, Coroutine
+from typing import Annotated, Any
+
+from fastapi import Depends
+from fastapi.security import OAuth2PasswordBearer
+from jose.jwt import get_unverified_claims
+
+from fastloom.auth import Claims
+from fastloom.auth.protocols import OAuth2Settings
+from fastloom.auth.schemas import UserClaims
+
+
+class OptionalJWTAuth:
+    settings: OAuth2Settings
+    _oauth2_schema: OAuth2PasswordBearer | None = None
+
+    def __init__(self, settings: OAuth2Settings):
+        self.settings = settings
+        self._oauth2_schema = OAuth2PasswordBearer(
+            str(settings.IAM_TOKEN_URL), auto_error=False
+        )
+
+    @classmethod
+    def _parse_token(cls, token: str) -> UserClaims:
+        return UserClaims.model_validate(get_unverified_claims(token))
+
+    @property
+    def get_claims(
+        self,
+    ) -> Callable[..., Coroutine[Any, Any, UserClaims | None]]:
+        async def _inner(
+            token: Annotated[str | None, Depends(self._oauth2_schema)],
+        ) -> UserClaims | None:
+            if token is None:
+                return None
+            claims = self._parse_token(token)
+            Claims.set(claims)
+            return claims
+
+        return _inner
+
+
+class JWTAuth(OptionalJWTAuth):
+    def __init__(self, settings: OAuth2Settings):
+        super().__init__(settings)
+        assert self._oauth2_schema is not None
+        self._oauth2_schema.auto_error = True
+
+    @property
+    def get_claims(self) -> Callable[..., Coroutine[Any, Any, UserClaims]]:
+        async def _inner(
+            token: Annotated[str, Depends(self._oauth2_schema)],
+        ) -> UserClaims:
+            claims = self._parse_token(token)
+            Claims.set(claims)
+            return claims
+
+        return _inner

fastloom-0.3.3/fastloom/auth/introspect/depends.py

@@ -0,0 +1,79 @@
+from collections.abc import Callable, Coroutine
+from typing import Annotated, Any
+
+import httpx
+from fastapi import Depends, HTTPException, Request
+from fastapi.security import OAuth2PasswordBearer
+
+from fastloom.auth.depends import JWTAuth, OptionalJWTAuth
+from fastloom.auth.introspect.schema import IntrospectionResponse
+from fastloom.auth.protocols import SidecarSettings
+from fastloom.auth.schemas import UserClaims
+
+
+class OptionalVerifiedAuth(OptionalJWTAuth):
+    settings: SidecarSettings
+    _oauth2_schema: OAuth2PasswordBearer | None = None
+
+    def __init__(self, settings: SidecarSettings):
+        super().__init__(settings)
+
+    async def _introspect(
+        self, token: Annotated[str, Depends(_oauth2_schema)]
+    ):
+        async with httpx.AsyncClient() as client:
+            response: httpx.Response = await client.post(
+                f"{self.settings.IAM_SIDECAR_URL}/introspect",
+                json=dict(token=token),
+            )
+        if response.status_code != 200:
+            raise HTTPException(status_code=403, detail=response.text)
+        data = IntrospectionResponse.model_validate(response.json())
+        if not data.active:
+            raise HTTPException(status_code=403, detail="Inactive token")
+
+    async def _acl(
+        self, request: Request, token: Annotated[str, Depends(_oauth2_schema)]
+    ) -> None:
+        async with httpx.AsyncClient() as client:
+            response: httpx.Response = await client.post(
+                url=f"{self.settings.IAM_SIDECAR_URL}/acl",
+                json={
+                    "token": token,
+                    "endpoint": request.url.path,
+                    "method": request.method,
+                },
+            )
+
+        if response.status_code != 200:
+            raise HTTPException(status_code=403, detail=response.text)
+        if not response.json():
+            raise HTTPException(status_code=403)
+
+    @property
+    def get_claims(
+        self,
+    ) -> Callable[..., Coroutine[Any, Any, UserClaims | None]]:
+        async def _inner(
+            request: Request, token: str | None = Depends(self._oauth2_schema)
+        ) -> UserClaims | None:
+            if token is None:
+                return None
+            await self._introspect(token)
+            await self._acl(request, token)
+            return await super(OptionalVerifiedAuth, self).get_claims(token)
+
+        return _inner
+
+
+class VerifiedAuth(JWTAuth, OptionalVerifiedAuth):
+    @property
+    def get_claims(self) -> Callable[..., Coroutine[Any, Any, UserClaims]]:
+        async def _inner(
+            request: Request, token: str = Depends(self._oauth2_schema)
+        ) -> UserClaims:
+            await self._introspect(token)
+            await self._acl(request, token)
+            return await super(VerifiedAuth, self).get_claims(token)
+
+        return _inner

fastloom-0.3.3/fastloom/auth/introspect/schema.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class IntrospectionResponse(BaseModel):
+    active: bool

fastloom-0.3.3/fastloom/auth/protocols.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+from typing import Protocol
+
+from pydantic import AnyHttpUrl
+
+
+class OAuth2Settings(Protocol):
+    IAM_TOKEN_URL: AnyHttpUrl | Path
+
+
+class SidecarSettings(OAuth2Settings, Protocol):
+    IAM_SIDECAR_URL: AnyHttpUrl

fastloom-0.3.3/fastloom/auth/schemas.py

@@ -0,0 +1,29 @@
+from pydantic import BaseModel, Field, computed_field, field_validator
+
+ADMIN_ROLE = "ADMIN"
+
+
+class Role(BaseModel):
+    name: str
+    users: list[str] | None = None
+
+
+class UserClaims(BaseModel):
+    tenant: str = Field(alias="owner")
+    id: str
+    username: str = Field(..., validation_alias="name")
+    email: str | None = None
+    phone: str | None = None
+    roles: list[Role] = Field(default_factory=list)
+
+    @field_validator("roles", mode="before")
+    @classmethod
+    def validate_roles(cls, v: list[Role] | None) -> list[Role]:
+        if not v:
+            return []
+        return v
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def is_admin(self) -> bool:
+        return any(role.name == ADMIN_ROLE for role in self.roles or [])

fastloom-0.3.3/fastloom/cache/base.py

@@ -0,0 +1,29 @@
+from aredis_om import Field, JsonModel
+
+from fastloom.cache.lifehooks import RedisHandler
+
+RedisHandler()
+
+
+class BaseCache(JsonModel):
+    class Meta:
+        global_key_prefix = "cache"
+        database = RedisHandler.redis
+        model_key_prefix = "base"
+        # ^should be overriden in sub
+
+    @property
+    async def invalidate(self):
+        return await self.expire(0)
+
+
+class BaseTenantSettingCache(BaseCache):
+    id: str = Field(primary_key=True)
+
+
+class HostTenantMapping(BaseCache, index=True):  # type: ignore[call-arg]
+    host: str = Field(primary_key=True)
+    tenant: str = Field(index=True)
+
+    class Meta:
+        model_key_prefix = "host_mapping"

fastloom-0.3.3/fastloom/cache/lifehooks.py

@@ -0,0 +1,28 @@
+from contextlib import suppress
+from os import getenv
+
+from aredis_om import get_redis_connection
+from redis import Redis
+from redis.exceptions import ConnectionError
+
+from fastloom.cache.settings import RedisSettings
+from fastloom.meta import SelfSustaining
+
+
+class RedisHandler(SelfSustaining):
+    enabled: bool
+    redis: Redis
+    sync_redis: Redis
+
+    def __init__(self):
+        super().__init__()
+        self.enabled = False
+        settings = RedisSettings.model_validate(
+            dict(redis_url=getenv("REDIS_OM_URL"))
+            if getenv("REDIS_OM_URL")
+            else {}
+        )
+        self.redis = get_redis_connection(url=str(settings.redis_url))
+        self.sync_redis = Redis.from_url(url=str(settings.redis_url))
+        with suppress(ConnectionError):
+            self.enabled = self.sync_redis

fastloom-0.3.3/fastloom/cache/settings.py

@@ -0,0 +1,9 @@
+from pydantic import (
+    BaseModel,
+    Field,
+    RedisDsn,
+)
+
+
+class RedisSettings(BaseModel):
+    redis_url: RedisDsn = Field(RedisDsn("redis://localhost:6379/0"))

fastloom-0.3.3/fastloom/crypto.py

@@ -0,0 +1,20 @@
+import secrets
+
+
+def generate_token(length: int):
+    """
+    Generates a n-digits numeral token, that used for OTP
+    """
+    min_value = 10 ** (length - 1)
+    max_value = 10**length - 1
+    return str(secrets.randbelow(max_value - min_value + 1) + min_value).zfill(
+        length
+    )
+
+
+def generate_alphanumeric_token(length: int):
+    """
+    Generates a n-digits alphanumeric token, that used for OTP
+    """
+    alphabet = "0123456789abcdefghijklmnopqrstuvwxyz"
+    return "".join(secrets.choice(alphabet) for _ in range(length))

fastloom-0.3.3/fastloom/date.py

@@ -0,0 +1,24 @@
+from datetime import date, datetime, time
+from zoneinfo import ZoneInfo
+
+import jdatetime  # type: ignore[import-untyped]
+
+
+def datetime_to_jalali(dt: datetime, date_only: bool = False) -> str:
+    dt = dt.astimezone(ZoneInfo("Asia/Tehran"))
+    return jdatetime.datetime.fromgregorian(datetime=dt).strftime(
+        "%Y/%m/%d" if date_only else "%Y/%m/%d - %H:%M"
+    )
+
+
+def utcnow() -> datetime:
+    return datetime.now(ZoneInfo("UTC"))
+
+
+def datetime_to_timestamp(value: datetime) -> int:
+    dt_utc = value.replace(tzinfo=ZoneInfo("UTC"))
+    return int(dt_utc.timestamp())
+
+
+def get_zero_time() -> datetime:
+    return datetime.combine(date.today(), time())

fastloom-0.3.3/fastloom/db/healthcheck.py

@@ -0,0 +1,22 @@
+from collections.abc import Callable, Coroutine
+from functools import partial
+from typing import Any
+
+
+class MongoConnectionError(Exception): ...
+
+
+async def check_mongo_connection(mongo_uri: str) -> None:
+    from pymongo import AsyncMongoClient
+
+    try:
+        client: AsyncMongoClient = AsyncMongoClient(mongo_uri, timeoutms=2000)
+        await client.admin.command("ping")
+    except Exception as er:
+        raise MongoConnectionError(f"MongoDB connection error: {er}") from er
+
+
+def get_healthcheck(
+    mongo_uri: str,
+) -> Callable[[], Coroutine[Any, Any, None]]:
+    return partial(check_mongo_connection, mongo_uri=mongo_uri)

fastloom-0.3.3/fastloom/db/lifehooks.py

@@ -0,0 +1,83 @@
+import pkgutil
+from collections.abc import Sequence
+from importlib import import_module
+from itertools import chain
+from types import ModuleType
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from beanie import Document, UnionDoc, View
+else:
+    try:
+        from beanie import Document, UnionDoc, View
+    except ImportError:
+        from pydantic import (
+            BaseModel as Document,
+        )
+        from pydantic import (
+            BaseModel as UnionDoc,
+        )
+        from pydantic import (
+            BaseModel as View,
+        )
+
+
+async def get_mongo_client(mongo_uri: str):
+    from pymongo import AsyncMongoClient
+
+    return AsyncMongoClient(
+        mongo_uri,
+        tz_aware=True,
+        connectTimeoutMS=1000,
+        serverSelectionTimeoutMS=5000,
+    )
+
+
+def get_models(
+    module: ModuleType,
+) -> list[type[Document] | type[UnionDoc] | type[View]]:
+    if (
+        module.__spec__ is None
+        or not module.__spec__.submodule_search_locations
+    ):
+        return [
+            x
+            for x in vars(module).values()
+            if isinstance(x, type)
+            and issubclass(x, Document | UnionDoc | View)
+            and x not in [Document, UnionDoc, View]
+        ]
+
+    return list(
+        chain.from_iterable(
+            get_models(import_module(f"{module.__name__}.{i.name}"))
+            for i in pkgutil.iter_modules(module.__path__)
+        )
+    )
+
+
+async def init_db(
+    database_name: str,
+    models: Sequence[type[Document] | type[UnionDoc] | type[View] | str],
+    mongo_uri: str,
+):
+    from beanie import init_beanie
+
+    client = await get_mongo_client(mongo_uri)
+    db = client[database_name]
+    await init_beanie(db, document_models=models, recreate_views=True)
+
+
+async def destroy_db(
+    database_name: str,
+    models: list[Document],
+    mongo_uri: str,
+    drop_database: bool = False,
+):
+    client = await get_mongo_client(mongo_uri)
+    db = client[database_name]
+    if not drop_database:
+        for model in models[1:]:  # Skip pre-populated Province collection
+            await db.drop_collection(model.Settings.name)
+    else:
+        await client.drop_database(database_name)

fastloom-0.3.3/fastloom/db/schemas.py

@@ -0,0 +1,91 @@
+from datetime import datetime
+from typing import Self
+
+import bson
+from beanie import (
+    Document,
+    Insert,
+    PydanticObjectId,
+    Replace,
+    SaveChanges,
+    Update,
+    before_event,
+)
+from fastapi import HTTPException, status
+from pydantic import BaseModel, Field, computed_field, field_validator
+
+from fastloom.date import utcnow
+
+
+class CreatedAtSchema(BaseModel):
+    created_at: datetime = Field(default_factory=utcnow)
+
+
+class CreatedUpdatedAtSchema(CreatedAtSchema):
+    """
+    ONLY use this mixin in `beanie.Document` models since it uses
+    @before_event decorator
+
+    NOTE: `updated_at` doesn't get updated when `update_many` is called
+    """
+
+    updated_at: datetime | None = Field(default_factory=utcnow)
+    # TODO ^ it shouldn't ideally be None, but some models used to save null
+    # so first we have to make sure we cleared db from all such instances
+
+    @before_event(Insert, Replace, SaveChanges, Update)
+    async def update_updated_at(self):
+        self.updated_at = utcnow()
+
+
+class BaseDocument(Document):
+    id: PydanticObjectId = Field(default_factory=bson.ObjectId, alias="_id")  # type: ignore[assignment] # noqa
+
+    @classmethod
+    async def get_or_404(cls, id: PydanticObjectId) -> Self:
+        obj: Self | None = await cls.get(id)
+        if obj is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"{cls.__name__} not found",
+            )
+        return obj
+
+    @classmethod
+    async def find_one_or_404(cls, *args, **kwargs) -> Self:
+        obj: Self | None = await cls.find_one(*args, **kwargs)
+        if obj is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"{cls.__name__} not found",
+            )
+        return obj
+
+
+class BasePaginationQuery(BaseModel):
+    offset: int | None = Field(None, ge=0)
+    limit: int | None = Field(None, ge=0)
+
+    @field_validator("limit", mode="after")
+    @classmethod
+    def convert_zero_limit(cls, v: int | None) -> int | None:
+        return v or None
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def skip(self) -> int | None:
+        if self.limit and self.offset is not None:
+            return self.limit * self.offset
+        return None
+
+
+class PaginatedResponse[T](BaseModel):
+    data: list[T] = Field(default_factory=list)
+    count: int = Field(default=0, ge=0)
+
+
+class BaseTenantSettingsDocument(Document, CreatedUpdatedAtSchema):
+    id: str  # type: ignore[assignment]
+
+    class Settings:
+        name = "settings"

fastloom-0.3.3/fastloom/db/settings.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class MongoSettings(BaseModel):
+    MONGO_URI: str
+    MONGO_DATABASE: str