fastapi-extra 0.1.9__cp312-cp312-win_amd64.whl → 0.2.1__cp312-cp312-win_amd64.whl

fastapi_extra/__init__.py

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

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/cache/redis.py

@@ -2,7 +2,7 @@ __author__ = "ziyan.yin"
 __date__ = "2025-01-17"
 
 
-from typing import Annotated, AsyncGenerator
+from typing import Annotated, AsyncGenerator, Self
 
 from fastapi.params import Depends
 from pydantic import BaseModel, Field, RedisDsn
@@ -23,37 +23,37 @@ class DefaultRedisSettings(Settings):
 
 
 _settings = DefaultRedisSettings()  # type: ignore
-_loaded_pools: list[ConnectionPool] = []
 
 
-class RedisCli(AbstractComponent):
+class RedisPool(AbstractComponent):
     default_config = _settings.redis
 
-    
     def __init__(self):
-        self._pool = None
+        self._pool: ConnectionPool | None = 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
-
+    @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() -> None:
-    for redis_pool in _loaded_pools:
-        redis_pool.aclose()
+    async def dispose(self) -> None:
+        if self._pool:
+            await self._pool.aclose()
 
 
 
-async def get_redis(redis_cli: RedisCli) -> AsyncGenerator[Redis, None]:
-    async with Redis(connection_pool=redis_cli.pool) as redis:
-        yield redis
+async def get_redis(pool: RedisPool) -> AsyncGenerator[Redis, None]:
+    async with RedisPool.get_client as client:
+        yield client
 
 
-DefaultRedis = Annotated[Redis, Depends(get_redis)]
+RedisCli = Annotated[Redis, Depends(get_redis)]

fastapi_extra/cursor.pyi

@@ -0,0 +1,8 @@
+__author__ = "ziyan.yin"
+__describe__ = ""
+
+
+class Cursor:
+    
+    def next_val(self) -> int:
+        ...

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/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/database/session.py

@@ -1,26 +1,68 @@
 __author__ = "ziyan.yin"
-__date__ = "2025-01-05"
+__date__ = "2024-12-26"
 
-
-from typing import Annotated, AsyncGenerator, Generator
+from typing import Annotated, AsyncGenerator, Literal, Self
 
 from fastapi.params import Depends
-from sqlmodel import Session
+from pydantic import AnyUrl, BaseModel, Field
+from sqlalchemy.ext.asyncio import create_async_engine
 from sqlmodel.ext.asyncio.session import AsyncSession
 
-from fastapi_extra.database.driver import DB, AsyncDB
+from fastapi_extra.dependency import AbstractComponent
+from fastapi_extra.settings import Settings
 
 
-async def get_async_session(db: AsyncDB) -> AsyncGenerator[AsyncSession, None]:
-    async with db.session as session:
-        yield session
-        await session.commit()
+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
 
-def get_session(db: DB) -> Generator[Session, None, None]:
-    with db.session as session:
+
+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
-        session.commit()
+        await session.commit()
 
 
-DefaultSession = Annotated[AsyncSession, Depends(get_async_session)]
+DefaultSession = Annotated[AsyncSession, Depends(get_session)]

fastapi_extra/dependency.py

@@ -1,36 +1,72 @@
 __author__ = "ziyan.yin"
 __date__ = "2025-01-05"
 
-
 from abc import ABCMeta
-from typing import Annotated, Any, Self
+from functools import update_wrapper
+from typing import Annotated, Any, Callable, ClassVar, Self, final
+
+from fastapi import Depends, FastAPI, Request
+
 
-from fastapi.params import Depends
+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,
-        annotated: bool = True
+        abstract: bool = False
     ):
         new_cls = super().__new__(mcs, name, bases, attrs)
-        if annotated:
-            return Annotated[new_cls, Depends(new_cls)]
+        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 AbstractDependency(metaclass=DependencyMetaClass, annotated=False):
+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
 
-class AbstractComponent(AbstractDependency, annotated=False):
+    @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__ = ()
-    __instance__: Any = None
-    
+    __load__ = None
+    __instance__ = None
+    __token__: ClassVar[str]
+
     def __new__(cls, *args, **kwargs) -> Self:
         if cls.__instance__ is None:
             cls.__instance__ = super().__new__(cls)

fastapi_extra/native/cursor.pyx

@@ -37,8 +37,8 @@ cdef class Cursor:
         self.cursor = count
         return (point << (_sequence_length + 4)) + (self.seed << _sequence_length) + count
 
-    def next_val(self) -> str:
+    def next_val(self) -> int:
         index = self.fetch()
         while index == 0:
             index = self.fetch()
-        return str(index)
+        return index

fastapi_extra/native/routing.pyx

@@ -3,80 +3,113 @@ __describe__ = ""
 
 cimport cython
 
-from typing import MutableMapping
-
 from starlette import _utils as starlette_utils
 from starlette.datastructures import URL
 from starlette.responses import RedirectResponse
 
 
+cdef int find_params(unicode path):
+    for i, ch in enumerate(path):
+        if ch == "{":
+            return i
+    return -1
+
+
+cdef int get_longest_common_prefix(unicode path, unicode node_path):
+    cdef int i
+    cdef int max_len = min(len(path), len(node_path))
+    for i in range(max_len):
+        if path[i] != node_path[i]:
+            return i
+    return max_len
+
+
 @cython.no_gc
 cdef class RouteNode:
+
     cdef readonly:
-        list routes
-        dict leaves
         unicode prefix
+        list params_routes
+        list static_routes
+        dict children
+    
+    cdef public object parent
 
-    def __cinit__(self, prefix):
+    def __cinit__(self, prefix: str):
         self.prefix = prefix
-        self.routes = []
-        self.leaves = {}
+        self.params_routes = []
+        self.static_routes = []
+        self.children = {}
+        self.parent = None
+    
+    def add_route(self, fullpath: str, handler: object):
+        wild_child = False
+        if (index := find_params(fullpath)) >= 0:
+            wild_child = True
+            path = fullpath[:index]
+        else:
+            path = fullpath
+        insert_route(self, path, wild_child, handler)
 
-    def add_route(self, route):
-        self.routes.append(route)
 
-    def add_leaf(self, node):
-        if node.prefix in self.leaves:
-            raise KeyError(node.prefix)
-        else:
-            self.leaves[node.prefix] = node
+cdef void insert_route(RouteNode node, unicode path, bint wild_child, object handler):
+    if node.prefix == path:
+        add_node(node, wild_child, handler)
+        return
 
+    cdef Py_UCS4 key = path.removeprefix(node.prefix)[0]
+    if key not in node.children:
+        add_child_node(node, key, path, wild_child, handler)
+        return
 
-cdef list change_path_to_ranks(unicode path):
-    ranks = path.lstrip('/').split('/')
-    return ranks
+    child_node = node.children[key]
+    i = get_longest_common_prefix(child_node.prefix, path)
+    longest_prefix = child_node.prefix[0: i]
+    if i == len(child_node.prefix):
+        insert_route(node.children[key], path, wild_child, handler)
+        return
+    next_node = RouteNode.__new__(RouteNode, longest_prefix)
+    next_node.parent = node
+    node.children[key] = next_node
+    next_node.children[child_node.prefix[i]] = child_node
+    child_node.parent = next_node
+    insert_route(next_node, path, wild_child, handler)
 
 
-cdef void add_route(unicode path, RouteNode root, object route):
-    current_node = root
-    ranks = change_path_to_ranks(path)
-    for r in ranks:
-        if r.find('{') >= 0 and r.find('}') > 0:
-            break
-        if not r:
-            continue
-        if r in current_node.leaves:
-            current_node = current_node.leaves[r]
-        else:
-            next_node = RouteNode.__new__(RouteNode, r)
-            current_node.add_leaf(next_node)
-            current_node = next_node
-    current_node.add_route(route)
-
-
-cdef list find_routes(unicode path, RouteNode root):
-    current_node = root
-    ranks = change_path_to_ranks(path)
-
-    routes = []
-    if current_node.routes:
-        routes += current_node.routes
-    for r in ranks:
-        if not r:
-            continue
-        if r in current_node.leaves:
-            current_node = current_node.leaves[r]
-            if current_node.routes:
-                routes += current_node.routes
-            continue
-        break
-    return routes
+cdef inline void add_child_node(RouteNode node, Py_UCS4 key, unicode path, bint wild_child, object handler):
+    child = RouteNode.__new__(RouteNode, path)
+    child.parent = node
+    add_node(child, wild_child, handler)
+    node.children[key] = child
+
+
+cdef inline void add_node(RouteNode node, bint wild_child, object handler):
+    if wild_child:
+        node.params_routes.append(handler)
+    else:
+        node.static_routes.append(handler)
 
 
 root_node = RouteNode.__new__(RouteNode, "")
 
 
-async def handle(router, scope, receive, send):
+cdef RouteNode search_node(unicode url):
+    cdef RouteNode current_node = root_node
+    cdef int n = len(url)
+    cdef int i = get_longest_common_prefix(url, current_node.prefix)
+    
+    while i < n:
+        key = url[i]
+        if key not in current_node.children:
+            break
+        current_node = current_node.children[key]
+        i = get_longest_common_prefix(url, current_node.prefix)
+
+    return current_node
+
+
+async def handle(scope, receive, send):
+    router = scope["app"].router
     assert scope["type"] in ("http", "websocket", "lifespan")
 
     if "router" not in scope:
@@ -90,46 +123,70 @@ async def handle(router, scope, receive, send):
 
     scope["path"] = route_path = starlette_utils.get_route_path(scope)
     scope["root_path"] = ""
-    matched_routes = find_routes(route_path, root_node)
-    n = len(matched_routes)
-
-    for i in range(n):
-        route = matched_routes[n - i - 1]
-        match, child_scope = route.matches(scope)
-        if match.value == 2:
-            scope.update(child_scope)
-            await route.handle(scope, receive, send)
-            return
-        elif match.value == 1 and partial is None:
-            partial = route
-            partial_scope = child_scope
+    leaf_node = search_node(route_path)
+
+    if leaf_node.prefix == route_path:
+        for route in leaf_node.static_routes:
+            match, child_scope = route.matches(scope)
+            if match.value == 2:
+                scope.update(child_scope)
+                await route.handle(scope, receive, send)
+                return
+            elif match.value == 1 and partial is None:
+                partial = route
+                partial_scope = child_scope
+    else:
+        current_node = leaf_node
+        routes = current_node.params_routes
+        while current_node.parent:
+            for route in routes:
+                match, child_scope = route.matches(scope)
+                if match.value == 2:
+                    scope.update(child_scope)
+                    await route.handle(scope, receive, send)
+                    return
+                elif match.value == 1 and partial is None:
+                    partial = route
+                    partial_scope = child_scope
+            current_node = current_node.parent
 
     if partial is not None:
         scope.update(partial_scope)
         await partial.handle(scope, receive, send)
         return
 
-
     if scope["type"] == "http" and router.redirect_slashes and route_path != "/":
         redirect_scope = dict(scope)
         if route_path.endswith("/"):
             redirect_scope["path"] = redirect_scope["path"].rstrip("/")
         else:
             redirect_scope["path"] = redirect_scope["path"] + "/"
-
-        for i in range(n):
-            route = matched_routes[n - i - 1]
-            match, child_scope = route.matches(redirect_scope)
-            if match.value != 0:
-                redirect_url = URL(scope=redirect_scope)
-                response = RedirectResponse(url=str(redirect_url))
-                await response(scope, receive, send)
-                return
+        
+        if leaf_node.prefix == redirect_scope["path"]:
+            for route in leaf_node.static_routes:
+                match, child_scope = route.matches(redirect_scope)
+                if match.value != 0:
+                    redirect_url = URL(scope=redirect_scope)
+                    response = RedirectResponse(url=str(redirect_url))
+                    await response(scope, receive, send)
+                    return
+        else:
+            current_node = leaf_node
+            routes = current_node.params_routes
+            while current_node.parent:
+                for route in routes:
+                    if match.value != 0:
+                        redirect_url = URL(scope=redirect_scope)
+                        response = RedirectResponse(url=str(redirect_url))
+                        await response(scope, receive, send)
+                        return
+                current_node = current_node.parent
 
     await router.default(scope, receive, send)
 
 
 def install(app):
     for route in app.routes:
-        add_route(route.path, root_node, route)
-    app.router.app = handle
+        root_node.add_route(route.path, route)
+
+    app.router.middleware_stack = handle

fastapi_extra/routing.pyi

@@ -0,0 +1,16 @@
+__author__ = "ziyan.yin"
+__describe__ = ""
+
+
+from typing import Any
+from fastapi import FastAPI
+
+
+class RouteNode:
+
+    def add_route(self, fullpath: str, handler: Any):
+        ...
+
+
+def install(app: FastAPI) -> None:
+    ...

{fastapi_extra-0.1.9.dist-info → fastapi_extra-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: fastapi-extra
-Version: 0.1.9
+Version: 0.2.1
 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.2.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+fastapi_extra/__init__.py,sha256=nZY4R9s4b2NNPoO6UZnpGbs_Vm2cXhT_Infu-VyNvWM,286
+fastapi_extra/cursor.cp312-win_amd64.pyd,sha256=nKZAYOxCrwr51-YZnXjKFTvpL6RKBMeQd55elvgiqhk,53760
+fastapi_extra/cursor.pyi,sha256=t1_ub-dRhu3OcXB_dIw5MdBG9r1n7853Vtgzc6bk6dw,115
+fastapi_extra/dependency.py,sha256=LtYnOTMyhOQUFSbNEViw7lxJvAFpPWbyuY4e2goSG-8,2130
+fastapi_extra/form.py,sha256=Fs9uEDOQThjFroDVTrjWnIGJ107BgXCppIVTymwQLzg,1247
+fastapi_extra/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_extra/response.py,sha256=DHvhOSgwot5eBNKuI_jPYxZ5rshZ55Xkg-FNBJlHD1E,9609
+fastapi_extra/routing.cp312-win_amd64.pyd,sha256=kOfgWarbRkQDTYZAh4LYvyEB5d6DoxnpfzOYbRl6qJk,91136
+fastapi_extra/routing.pyi,sha256=QslcOUnVJqFCqt14VJQwjUYQ7Qd3bQBTo34Yx1xS7TA,243
+fastapi_extra/settings.py,sha256=cCcwaper5GiNNoT4gNKqf-iloSOTNnMsiUR0knJx4Mw,1461
+fastapi_extra/types.py,sha256=3z6gUnao6WZL76asZYmex20xfY9mvYA-RbnsxUcui30,819
+fastapi_extra/utils.py,sha256=tsPX3kpF_P5D9Bd3gnlG6rkVsLkv5gbxjml-s6ZL_6I,346
+fastapi_extra/cache/__init__.py,sha256=kq4b_AYKCSJ0fEp4rqpeaoNJilko4XbtfC81xzUaYGI,122
+fastapi_extra/cache/redis.py,sha256=-hr2DRkmruzH4cIArdjsytqRiiWWtDJt9GIDy38wmtQ,1600
+fastapi_extra/database/__init__.py,sha256=pCYUoEylTponWqpR0AXJHcRo_cs4fnEXVVV9B5J9rt0,384
+fastapi_extra/database/model.py,sha256=2lDi9PQ5F0PSM7BGZozZf1wSefpXnTWqAVzEyGPaXRI,2453
+fastapi_extra/database/service.py,sha256=-tBC17jEbGZhnxdtWyftP2BUXfCwcOtxzNZ53qLp518,1798
+fastapi_extra/database/session.py,sha256=PALArHhXNS2gCgeMkiKjyatvINV_VW1LjgEIwXDKyfQ,1903
+fastapi_extra/native/cursor.pyx,sha256=GchJIPY6e5scuyl1BbA-Et0CdRcHOI3xgsTvDem0B70,1141
+fastapi_extra/native/routing.pyx,sha256=DfK83nSwI2l8KATZ9YXLXjMXSy42YxjxZvwhQEpa0fI,6262
+fastapi_extra-0.2.1.dist-info/licenses/LICENSE,sha256=0vTjHDa3VDsxTT-R-sH6SpYcA2F1hKtbX9ZFZQm-EcU,1516
+fastapi_extra-0.2.1.dist-info/METADATA,sha256=ii3OEMR1gHqVOIQzzDTQiGNVXQXqmT_NtRthARtu_is,1371
+fastapi_extra-0.2.1.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+fastapi_extra-0.2.1.dist-info/top_level.txt,sha256=B7D80bEftE2E-eSd1be2r9BWkLLMZN21dRTWpb4y4Ig,14
+fastapi_extra-0.2.1.dist-info/RECORD,,

{fastapi_extra-0.1.9.dist-info → fastapi_extra-0.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64
 

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.dist-info/RECORD

@@ -1,24 +0,0 @@
-fastapi_extra/__init__.py,sha256=lpfuCAfLTXtsdNSd8ouWB-l-VLdZ-FfaAo7-vTJeh9k,286
-fastapi_extra/cursor.cp312-win_amd64.pyd,sha256=PobPLIMw1W_RCM4S6tWkLsywbir5wdz7dVBbMvlNiPs,57344
-fastapi_extra/dependency.py,sha256=8SgAky63hMa9pnttqRRZMyPAa3BwBMUvFA3ZLH86h44,910
-fastapi_extra/form.py,sha256=Fs9uEDOQThjFroDVTrjWnIGJ107BgXCppIVTymwQLzg,1247
-fastapi_extra/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastapi_extra/response.py,sha256=DHvhOSgwot5eBNKuI_jPYxZ5rshZ55Xkg-FNBJlHD1E,9609
-fastapi_extra/routing.cp312-win_amd64.pyd,sha256=HqWjCP-jfZPw3l95pH8Im-NQT7d70TaywE_05CGXbl8,94720
-fastapi_extra/settings.py,sha256=cCcwaper5GiNNoT4gNKqf-iloSOTNnMsiUR0knJx4Mw,1461
-fastapi_extra/types.py,sha256=3z6gUnao6WZL76asZYmex20xfY9mvYA-RbnsxUcui30,819
-fastapi_extra/utils.py,sha256=tsPX3kpF_P5D9Bd3gnlG6rkVsLkv5gbxjml-s6ZL_6I,346
-fastapi_extra/cache/__init__.py,sha256=2bwWFRf6giDo0QiFWEvekQwga9kGTK_9BJdxe32Nru8,126
-fastapi_extra/cache/redis.py,sha256=fLNJfL8V-HYek38WVNwxvW6cnd7rJpcd62vy4O07C44,1592
-fastapi_extra/database/__init__.py,sha256=B59umaoNjDuXyoNh7EYWYEk4xr9tfgVjXsSaOPz3y_Q,328
-fastapi_extra/database/driver.py,sha256=ar_vnfqjpoWjiW5eEdrisyi9CrhfdHtbhAGFxGMKC5E,2223
-fastapi_extra/database/model.py,sha256=2lDi9PQ5F0PSM7BGZozZf1wSefpXnTWqAVzEyGPaXRI,2453
-fastapi_extra/database/service.py,sha256=TdKlcTQ_WoMqy-kmlYUcFKF7XpyFL8O4vkQ2glZc7P4,1495
-fastapi_extra/database/session.py,sha256=cpKj_NDBSATRCBbmfyYa4v-TKGrMMgRJQCEnkCR153s,691
-fastapi_extra/native/cursor.pyx,sha256=bESprFDgk9gGjyPQ4YCSg51dov2WB6s60XrOs3r5-r0,1146
-fastapi_extra/native/routing.pyx,sha256=GrdGAoBospwCpxMHBon5cuRYcz9ifAFSSYa2Ytf49lg,3841
-fastapi_extra-0.1.9.dist-info/LICENSE,sha256=0vTjHDa3VDsxTT-R-sH6SpYcA2F1hKtbX9ZFZQm-EcU,1516
-fastapi_extra-0.1.9.dist-info/METADATA,sha256=_ZjrmeVVPTOQZEPykPyaFVnr3odZ917x8N2xuEk4aW4,1348
-fastapi_extra-0.1.9.dist-info/WHEEL,sha256=A8mRFNvJcDL8dRPZ6k2ICKEOXwE8pzYFXYxEla0rR0g,101
-fastapi_extra-0.1.9.dist-info/top_level.txt,sha256=B7D80bEftE2E-eSd1be2r9BWkLLMZN21dRTWpb4y4Ig,14
-fastapi_extra-0.1.9.dist-info/RECORD,,