fastapi-extra 0.1.5__tar.gz → 0.1.6__tar.gz

{fastapi_extra-0.1.5 → fastapi_extra-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fastapi-extra
-Version: 0.1.5
+Version: 0.1.6
 Summary: extra package for fastapi.
 Author-email: Ziyan Yin <408856732@qq.com>
 License: BSD-3-Clause

{fastapi_extra-0.1.5 → fastapi_extra-0.1.6}/fastapi_extra/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.5"
+__version__ = "0.1.6"
 
 
 from fastapi import FastAPI

fastapi_extra-0.1.6/fastapi_extra/cache/__init__.py

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

fastapi_extra-0.1.6/fastapi_extra/cache/redis.py

@@ -0,0 +1,59 @@
+__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 AbstractWidget
+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(AbstractWidget):
+    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.5 → fastapi_extra-0.1.6}/fastapi_extra/database/__init__.py

@@ -4,14 +4,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 AsyncSessionMaker
 from fastapi_extra.database.session import DefaultSession as Session
-from fastapi_extra.database.session import SessionMaker
 
 __all__ = [
     "AsyncSessionMaker",
     "ModelService",
     "Session",
-    "SessionMaker",
     "SQLBase"
 ]

fastapi_extra-0.1.6/fastapi_extra/database/driver.py

@@ -0,0 +1,81 @@
+__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 AbstractWidget
+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(AbstractWidget):
+    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:
+        return AsyncEngine(super().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.6/fastapi_extra/database/session.py

@@ -0,0 +1,24 @@
+__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
+
+
+def get_session(db: DB) -> Generator[Session, None, None]:
+    with db.session as session:
+        yield session
+
+
+DefaultSession = Annotated[AsyncSession, Depends(get_async_session)]

{fastapi_extra-0.1.5 → fastapi_extra-0.1.6}/fastapi_extra.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fastapi-extra
-Version: 0.1.5
+Version: 0.1.6
 Summary: extra package for fastapi.
 Author-email: Ziyan Yin <408856732@qq.com>
 License: BSD-3-Clause

{fastapi_extra-0.1.5 → fastapi_extra-0.1.6}/fastapi_extra.egg-info/SOURCES.txt

@@ -18,7 +18,7 @@ fastapi_extra/native/routing.pyx
 fastapi_extra/cache/__init__.py
 fastapi_extra/cache/redis.py
 fastapi_extra/database/__init__.py
-fastapi_extra/database/engine.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.5/fastapi_extra/cache/__init__.py

@@ -1,10 +0,0 @@
-__author__ = "ziyan.yin"
-__date__ = "2025-01-10"
-
-from .redis import Redis, RedisCli, RedisMaker
-
-__all__ = [
-    "Redis",
-    "RedisMaker",
-    "RedisCli"
-]

fastapi_extra-0.1.5/fastapi_extra/cache/redis.py

@@ -1,52 +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.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
-
-
-def load_pool(config: RedisConfig) -> ConnectionPool:
-    return ConnectionPool.from_url(
-        config.url, 
-        **config.model_dump(exclude_defaults=True, exclude={"url", "connection_kwargs"}), 
-        **config.connection_kwargs
-    )
-
-
-_settings = DefaultRedisSettings()  # type: ignore
-DEFAULT_POOL = load_pool(_settings.redis)
-
-
-async def dispose() -> None:
-    await DEFAULT_POOL.aclose()
-
-
-class RedisMaker(Depends):
-    
-    def __init__(self, pool: ConnectionPool):
-        super().__init__()
-        self.dependency = self
-        self.pool = pool
-    
-    async def __call__(self) -> AsyncGenerator[Redis, None]:
-        async with Redis(connection_pool=self.pool) as session:
-            yield session
-
-
-RedisCli = Annotated[Redis, RedisMaker(DEFAULT_POOL)]

fastapi_extra-0.1.5/fastapi_extra/database/engine.py

@@ -1,50 +0,0 @@
-__author__ = "ziyan.yin"
-__date__ = "2024-12-26"
-
-
-from typing import Any, Literal
-
-from pydantic import AnyUrl, BaseModel, Field
-from sqlalchemy import Engine, NullPool
-from sqlalchemy.util import _concurrency_py3k
-from sqlmodel import create_engine
-
-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
-    
-
-def load_engine(config: DatabaseConfig, **kw: Any) -> Engine:
-    return create_engine(
-        url=str(config.url),
-        **config.model_dump(exclude_defaults=True, exclude={"url", "options"}), 
-        **config.options,
-        **kw
-    )
-    
-
-_settings = DefaultDatabaseSettings()  # type: ignore
-if _settings.mode == "test":
-    DEFAULT_ENGINE: Engine = load_engine(_settings.datasource, poolclass=NullPool)
-else:
-    DEFAULT_ENGINE: Engine = load_engine(_settings.datasource)
-
-
-async def dispose() -> None:
-    await _concurrency_py3k.greenlet_spawn(DEFAULT_ENGINE.dispose)

fastapi_extra-0.1.5/fastapi_extra/database/session.py

@@ -1,39 +0,0 @@
-__author__ = "ziyan.yin"
-__date__ = "2025-01-05"
-
-
-from typing import Annotated, AsyncGenerator, Generator
-
-from fastapi.params import Depends
-from sqlalchemy.ext.asyncio import AsyncEngine
-from sqlmodel import Session as _Session
-from sqlmodel.ext.asyncio.session import AsyncSession
-
-from fastapi_extra.database.engine import DEFAULT_ENGINE, Engine
-
-
-class SessionMaker(Depends):
-    __slots__ = ("engine", )
-    
-    def __init__(self, engine: Engine):
-        super().__init__()
-        self.engine = engine
-        self.dependency = self
-
-    def __call__(self) -> Generator[_Session, None, None]:
-        with _Session(self.engine) as session:
-            yield session
-
-
-class AsyncSessionMaker(SessionMaker):
-    
-    def __init__(self, engine: Engine):
-        super().__init__(engine)
-        self.async_engine: AsyncEngine = AsyncEngine(self.engine)
-    
-    async def __call__(self) -> AsyncGenerator[AsyncSession, None]:
-        async with AsyncSession(self.async_engine) as session:
-            yield session
-            
-
-DefaultSession = Annotated[AsyncSession, AsyncSessionMaker(DEFAULT_ENGINE)]