fastapi-extra 0.1.9__tar.gz → 0.2.0__tar.gz

{fastapi_extra-0.1.9 → fastapi_extra-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: fastapi-extra
-Version: 0.1.9
+Version: 0.2.0
 Summary: extra package for fastapi.
 Author-email: Ziyan Yin <408856732@qq.com>
 License: BSD-3-Clause
@@ -32,3 +32,4 @@ Provides-Extra: pgsql
 Requires-Dist: asyncpg; extra == "pgsql"
 Provides-Extra: aiomysql
 Requires-Dist: aiomysql; extra == "aiomysql"
+Dynamic: license-file

{fastapi_extra-0.1.9 → fastapi_extra-0.2.0}/fastapi_extra/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.9"
+__version__ = "0.2.0"
 
 
 from fastapi import FastAPI

{fastapi_extra-0.1.9 → fastapi_extra-0.2.0}/fastapi_extra/cache/__init__.py

@@ -1,7 +1,7 @@
 __author__ = "ziyan.yin"
 __date__ = "2025-01-10"
 
-from .redis import DefaultRedis as Redis
+from .redis import RedisCli as Redis
 
 __all__ = [
     "Redis"

fastapi_extra-0.2.0/fastapi_extra/cache/redis.py

@@ -0,0 +1,59 @@
+__author__ = "ziyan.yin"
+__date__ = "2025-01-17"
+
+
+from typing import Annotated, AsyncGenerator, Self
+
+from fastapi.params import Depends
+from pydantic import BaseModel, Field, RedisDsn
+from redis.asyncio import ConnectionPool, Redis
+
+from fastapi_extra.dependency import AbstractComponent
+from fastapi_extra.settings import Settings
+
+
+class RedisConfig(BaseModel):
+    url: RedisDsn = RedisDsn("redis://localhost:6379/0")
+    max_connections: int | None = None
+    connection_kwargs: dict = Field(default_factory=dict)
+
+
+class DefaultRedisSettings(Settings):
+    redis: RedisConfig
+
+
+_settings = DefaultRedisSettings()  # type: ignore
+
+
+class RedisPool(AbstractComponent):
+    default_config = _settings.redis
+
+    def __init__(self):
+        self._pool: ConnectionPool | None = None
+    
+    @classmethod
+    def setup(cls, **options) -> Self:
+        redis = cls()
+        redis._pool = ConnectionPool.from_url(
+            cls.default_config.url, 
+            **cls.default_config.model_dump(exclude_defaults=True, exclude={"url", "connection_kwargs"}), 
+            **cls.default_config.connection_kwargs
+            **options
+        )
+        return redis
+    
+    def get_client(self) -> Redis:
+        return Redis(connection_pool=self._pool)
+
+    async def dispose(self) -> None:
+        if self._pool:
+            await self._pool.aclose()
+
+
+
+async def get_redis(pool: RedisPool) -> AsyncGenerator[Redis, None]:
+    async with RedisPool.get_client as client:
+        yield client
+
+
+RedisCli = Annotated[Redis, Depends(get_redis)]

{fastapi_extra-0.1.9 → fastapi_extra-0.2.0}/fastapi_extra/database/__init__.py

@@ -5,10 +5,11 @@ __date__ = "2025-01-05"
 from fastapi_extra.database.model import SQLBase
 from fastapi_extra.database.service import ModelService
 from fastapi_extra.database.session import DefaultSession as Session
+from fastapi_extra.database.session import SessionFactory
 
 __all__ = [
-    "AsyncSessionMaker",
-    "ModelService",
+    "SessionFactory",
     "Session",
-    "SQLBase"
+    "SQLBase",
+    "ModelService"
 ]

{fastapi_extra-0.1.9 → fastapi_extra-0.2.0}/fastapi_extra/database/service.py

@@ -1,18 +1,20 @@
 __author__ = "ziyan.yin"
 __date__ = "2025-01-12"
 
+from contextvars import ContextVar
 from typing import Any, Generic, Self, TypeVar
 
 from fastapi_extra.database.model import SQLModel
 from fastapi_extra.database.session import DefaultSession
-from fastapi_extra.dependency import AbstractDependency
+from fastapi_extra.dependency import AbstractService
 
 Model = TypeVar("Model", bound=SQLModel)
 
 
-class ModelService(AbstractDependency, Generic[Model], annotated=False):
-    __slot__ = ("session", )
+class ModelService(AbstractService, Generic[Model], abstract=True):
+    __slot__ = ()
     __model__: Model
+    __session_container__ = ContextVar("__session_container__", default=None)
     
     @classmethod
     def __class_getitem__(cls, item: type[SQLModel]) -> Self:
@@ -27,7 +29,13 @@ class ModelService(AbstractDependency, Generic[Model], annotated=False):
         return SubService
 
     def __init__(self, session: DefaultSession):
-        self.session = session
+        self.__session_container__.set(session)
+    
+    @property
+    def session(self):
+        _session = self.__session_container__.get()
+        assert _session is not None, "Session is not initialized"
+        return _session
 
     async def get(self, ident: int | str, **kwargs: Any) -> Model | None:
         return await self.session.get(self.__model__, ident, **kwargs)

fastapi_extra-0.2.0/fastapi_extra/database/session.py

@@ -0,0 +1,68 @@
+__author__ = "ziyan.yin"
+__date__ = "2024-12-26"
+
+from typing import Annotated, AsyncGenerator, Literal, Self
+
+from fastapi.params import Depends
+from pydantic import AnyUrl, BaseModel, Field
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from fastapi_extra.dependency import AbstractComponent
+from fastapi_extra.settings import Settings
+
+
+class DatabaseConfig(BaseModel):
+    url: AnyUrl
+    echo: bool = False
+    echo_pool: bool = False
+    isolation_level: Literal[
+        "SERIALIZABLE",
+        "REPEATABLE READ",
+        "READ COMMITTED",
+        "READ UNCOMMITTED",
+        "AUTOCOMMIT",
+    ] | None = None
+    options: dict = Field(default_factory=dict)
+
+
+class DefaultDatabaseSettings(Settings):
+    datasource: DatabaseConfig
+
+
+_settings = DefaultDatabaseSettings()  # type: ignore
+
+
+class SessionFactory(AbstractComponent):
+    __slot__ = ("_engine",)
+    default_config = _settings.datasource
+    
+    def __init__(self):
+        self._engine = None
+    
+    @classmethod
+    def setup(cls, **options) -> Self:
+        db = cls()
+        db._engine = create_async_engine(
+            url=str(cls.default_config.url),
+            **cls.default_config.model_dump(exclude_defaults=True, exclude={"url", "options"}), 
+            **cls.default_config.options,
+            **options
+        )
+        return db
+
+    def create_session(self) -> AsyncSession:
+        return AsyncSession(self._engine)
+
+    async def dispose(self) -> None:
+        if self._engine:
+            await self._engine.dispose()
+
+
+async def get_session(factory: SessionFactory) -> AsyncGenerator[AsyncSession, None]:
+    async with factory.create_session() as session:
+        yield session
+        await session.commit()
+
+
+DefaultSession = Annotated[AsyncSession, Depends(get_session)]

fastapi_extra-0.2.0/fastapi_extra/dependency.py

@@ -0,0 +1,73 @@
+__author__ = "ziyan.yin"
+__date__ = "2025-01-05"
+
+from abc import ABCMeta
+from functools import update_wrapper
+from typing import Annotated, Any, Callable, ClassVar, Self, final
+
+from fastapi import Depends, FastAPI, Request
+
+
+def async_wrapper(func: Callable):
+    
+    async def func_wrapper(*args, **kwds):
+        return func(*args, **kwds)
+    
+    return update_wrapper(func_wrapper, func)
+
+
+class DependencyMetaClass(ABCMeta):
+    __load__ = None
+    __token__ = None
+    
+    def __new__(
+        mcs,
+        name: str,
+        bases: tuple[type, ...],
+        attrs: dict,
+        abstract: bool = False
+    ):
+        new_cls = super().__new__(mcs, name, bases, attrs)
+        new_cls.__token__ = f"{new_cls.__module__}.{new_cls.__name__}"
+        if not abstract:
+            if not new_cls.__load__:
+                return Annotated[new_cls, Depends(async_wrapper(new_cls))]
+            return Annotated[new_cls, Depends(new_cls.__load__)]
+        return new_cls
+
+
+class AbstractComponent(metaclass=DependencyMetaClass, abstract=True):
+    __slot__ = ()
+    __token__: ClassVar[str]
+
+    @classmethod
+    def setup(cls, *args: Any, **kwargs: Any) -> Self:
+        raise NotImplementedError
+
+    @final
+    @classmethod
+    def install(cls, app: FastAPI, *args: Any, **kwargs: Any) -> Self:
+        component = cls.setup(*args, **kwargs)
+        setattr(app.state, cls.__token__, component)
+        return component
+
+    @final
+    @classmethod
+    async def __load__(cls, request: Request) -> Self:
+        assert hasattr(request.app.state, cls.__token__), f"{cls.__name__} must be installed in lifespan"
+        return getattr(request.app.state, cls.__token__)
+
+    async def dispose(self) -> None:
+        pass
+
+
+class AbstractService(metaclass=DependencyMetaClass, abstract=True):
+    __slot__ = ()
+    __load__ = None
+    __instance__ = None
+    __token__: ClassVar[str]
+
+    def __new__(cls, *args, **kwargs) -> Self:
+        if cls.__instance__ is None:
+            cls.__instance__ = super().__new__(cls)
+        return cls.__instance__

{fastapi_extra-0.1.9 → fastapi_extra-0.2.0}/fastapi_extra.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: fastapi-extra
-Version: 0.1.9
+Version: 0.2.0
 Summary: extra package for fastapi.
 Author-email: Ziyan Yin <408856732@qq.com>
 License: BSD-3-Clause
@@ -32,3 +32,4 @@ Provides-Extra: pgsql
 Requires-Dist: asyncpg; extra == "pgsql"
 Provides-Extra: aiomysql
 Requires-Dist: aiomysql; extra == "aiomysql"
+Dynamic: license-file

{fastapi_extra-0.1.9 → fastapi_extra-0.2.0}/fastapi_extra.egg-info/SOURCES.txt

@@ -19,7 +19,6 @@ fastapi_extra/native/routing.pyx
 fastapi_extra/cache/__init__.py
 fastapi_extra/cache/redis.py
 fastapi_extra/database/__init__.py
-fastapi_extra/database/driver.py
 fastapi_extra/database/model.py
 fastapi_extra/database/service.py
 fastapi_extra/database/session.py

fastapi_extra-0.1.9/fastapi_extra/cache/redis.py

@@ -1,59 +0,0 @@
-__author__ = "ziyan.yin"
-__date__ = "2025-01-17"
-
-
-from typing import Annotated, AsyncGenerator
-
-from fastapi.params import Depends
-from pydantic import BaseModel, Field, RedisDsn
-from redis.asyncio import ConnectionPool, Redis
-
-from fastapi_extra.dependency import AbstractComponent
-from fastapi_extra.settings import Settings
-
-
-class RedisConfig(BaseModel):
-    url: RedisDsn = RedisDsn("redis://localhost:6379/0")
-    max_connections: int | None = None
-    connection_kwargs: dict = Field(default_factory=dict)
-
-
-class DefaultRedisSettings(Settings):
-    redis: RedisConfig
-
-
-_settings = DefaultRedisSettings()  # type: ignore
-_loaded_pools: list[ConnectionPool] = []
-
-
-class RedisCli(AbstractComponent):
-    default_config = _settings.redis
-
-    
-    def __init__(self):
-        self._pool = None
-    
-    @property
-    def pool(self) -> ConnectionPool:
-        if not self._pool:
-            self._pool = ConnectionPool.from_url(
-                self.default_config.url, 
-                **self.default_config.model_dump(exclude_defaults=True, exclude={"url", "connection_kwargs"}), 
-                **self.default_config.connection_kwargs
-            )
-            _loaded_pools.append(self)
-        return self._pool
-
-
-async def dispose() -> None:
-    for redis_pool in _loaded_pools:
-        redis_pool.aclose()
-
-
-
-async def get_redis(redis_cli: RedisCli) -> AsyncGenerator[Redis, None]:
-    async with Redis(connection_pool=redis_cli.pool) as redis:
-        yield redis
-
-
-DefaultRedis = Annotated[Redis, Depends(get_redis)]

fastapi_extra-0.1.9/fastapi_extra/database/driver.py

@@ -1,83 +0,0 @@
-__author__ = "ziyan.yin"
-__date__ = "2024-12-26"
-
-
-from typing import Literal
-
-from pydantic import AnyUrl, BaseModel, Field
-from sqlalchemy import Engine, NullPool
-from sqlalchemy.ext.asyncio import AsyncEngine
-from sqlalchemy.util import _concurrency_py3k
-from sqlmodel import Session, create_engine
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from fastapi_extra.dependency import AbstractComponent
-from fastapi_extra.settings import Settings
-
-
-class DatabaseConfig(BaseModel):
-    url: AnyUrl
-    echo: bool = False
-    echo_pool: bool = False
-    isolation_level: Literal[
-        "SERIALIZABLE",
-        "REPEATABLE READ",
-        "READ COMMITTED",
-        "READ UNCOMMITTED",
-        "AUTOCOMMIT",
-    ] | None = None
-    options: dict = Field(default_factory=dict)
-
-
-class DefaultDatabaseSettings(Settings):
-    datasource: DatabaseConfig
-
-
-_settings = DefaultDatabaseSettings()  # type: ignore
-_loaded_engines: list[Engine] = []
-
-
-class DB(AbstractComponent):
-    default_config = _settings.datasource
-    default_options = {}
-    
-    def __init__(self):
-        self._engine = None
-    
-    @property
-    def engine(self) -> Engine:
-        if not self._engine:
-            self._engine = create_engine(
-                url=str(self.default_config.url),
-                **self.default_config.model_dump(exclude_defaults=True, exclude={"url", "options"}), 
-                **self.default_config.options,
-                **self.default_options
-            )
-            _loaded_engines.append(self._engine)
-        return self._engine
-
-    @property
-    def session(self) -> Session:
-        return Session(self.engine)
-
-
-class AsyncDB(DB):
-    
-    @property
-    def engine(self) -> AsyncEngine:
-        if not self._engine:
-            self._engine = AsyncEngine(super().engine)
-        return self._engine
-
-    @property
-    def session(self) -> AsyncSession:
-        return AsyncSession(self.engine)
-        
-
-if _settings.mode == "test":
-    DB.default_options = {"poolclass": NullPool}
-
-
-async def dispose() -> None:
-    for engine in _loaded_engines:
-        await _concurrency_py3k.greenlet_spawn(engine.dispose)

fastapi_extra-0.1.9/fastapi_extra/database/session.py

@@ -1,26 +0,0 @@
-__author__ = "ziyan.yin"
-__date__ = "2025-01-05"
-
-
-from typing import Annotated, AsyncGenerator, Generator
-
-from fastapi.params import Depends
-from sqlmodel import Session
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from fastapi_extra.database.driver import DB, AsyncDB
-
-
-async def get_async_session(db: AsyncDB) -> AsyncGenerator[AsyncSession, None]:
-    async with db.session as session:
-        yield session
-        await session.commit()
-
-
-def get_session(db: DB) -> Generator[Session, None, None]:
-    with db.session as session:
-        yield session
-        session.commit()
-
-
-DefaultSession = Annotated[AsyncSession, Depends(get_async_session)]

fastapi_extra-0.1.9/fastapi_extra/dependency.py

@@ -1,37 +0,0 @@
-__author__ = "ziyan.yin"
-__date__ = "2025-01-05"
-
-
-from abc import ABCMeta
-from typing import Annotated, Any, Self
-
-from fastapi.params import Depends
-
-
-class DependencyMetaClass(ABCMeta):
-    
-    def __new__(
-        mcs,
-        name: str,
-        bases: tuple[type, ...],
-        attrs: dict,
-        annotated: bool = True
-    ):
-        new_cls = super().__new__(mcs, name, bases, attrs)
-        if annotated:
-            return Annotated[new_cls, Depends(new_cls)]
-        return new_cls
-
-
-class AbstractDependency(metaclass=DependencyMetaClass, annotated=False):
-    __slot__ = ()
-
-
-class AbstractComponent(AbstractDependency, annotated=False):
-    __slot__ = ()
-    __instance__: Any = None
-    
-    def __new__(cls, *args, **kwargs) -> Self:
-        if cls.__instance__ is None:
-            cls.__instance__ = super().__new__(cls)
-        return cls.__instance__