fastapi-sqla 3.1.1__py3-none-any.whl → 3.4.8__py3-none-any.whl

fastapi_sqla/__init__.py

@@ -1,4 +1,4 @@
-from fastapi_sqla.base import setup
+from fastapi_sqla.base import setup, setup_middlewares, startup
 from fastapi_sqla.models import Collection, Item, Page
 from fastapi_sqla.pagination import Paginate, PaginateSignature, Pagination
 from fastapi_sqla.sqla import (
@@ -22,6 +22,8 @@ __all__ = [
     "SqlaSession",
     "open_session",
     "setup",
+    "setup_middlewares",
+    "startup",
 ]
 
 

fastapi_sqla/_pytest_plugin.py

@@ -28,7 +28,6 @@ def db_host():
     When CI key is set in environment variables, it uses `postgres` as host name else,
     host used is `localhost`
     """
-
     return "postgres" if "CI" in os.environ else "localhost"
 
 
@@ -38,7 +37,6 @@ def db_user():
 
     postgres
     """
-
     return "postgres"
 
 
@@ -48,7 +46,6 @@ def db_url(db_host, db_user):
 
     db url example postgresql://{db_user}@{db_host}/postgres
     """
-
     return f"postgresql://{db_user}@{db_host}/postgres"
 
 
@@ -107,7 +104,6 @@ def sqla_reflection(sqla_modules, sqla_connection):
 @fixture
 def patch_engine_from_config(request, sqla_connection):
     """So that all DB operations are never written to db for real."""
-
     if "dont_patch_engines" in request.keywords:
         yield
     else:
@@ -153,7 +149,7 @@ def async_sqlalchemy_url(db_url):
     return format_async_async_sqlalchemy_url(db_url)
 
 
-if asyncio_support:  # noqa: C901
+if asyncio_support:
 
     @fixture
     def async_engine(async_sqlalchemy_url):
@@ -167,7 +163,6 @@ if asyncio_support:  # noqa: C901
     @fixture
     async def patch_new_engine(request, async_sqla_connection):
         """So that all async DB operations are never written to db for real."""
-
         if "dont_patch_engines" in request.keywords:
             yield
         else:

fastapi_sqla/async_pagination.py

@@ -1,12 +1,12 @@
 import math
-from collections.abc import Awaitable, Callable
-from typing import Annotated, Iterator, Optional, Union, cast
+from collections.abc import Awaitable, Callable, Iterator
+from typing import Annotated, Optional, Union, cast
 
 from fastapi import Depends, Query
 from sqlalchemy.sql import Select, func, select
 
 from fastapi_sqla.async_sqla import AsyncSessionDependency, SqlaAsyncSession
-from fastapi_sqla.models import Page
+from fastapi_sqla.models import Meta, Page
 from fastapi_sqla.sqla import _DEFAULT_SESSION_KEY
 
 QueryCountDependency = Callable[..., Awaitable[int]]
@@ -19,7 +19,7 @@ PaginateDependency = Union[DefaultDependency, WithQueryCountDependency]
 
 
 async def default_query_count(session: SqlaAsyncSession, query: Select) -> int:
-    result = await session.execute(select(func.count()).select_from(query.subquery()))  # type: ignore # noqa
+    result = await session.execute(select(func.count()).select_from(query.subquery()))
     return cast(int, result.scalar())
 
 
@@ -33,20 +33,20 @@ async def paginate_query(
     scalars: bool = True,
 ) -> Page:
     total_pages = math.ceil(total_items / limit)
-    page_number = offset / limit + 1
-    query = query.offset(offset).limit(limit)  # type: ignore
+    page_number = math.floor(offset / limit + 1)
+    query = query.offset(offset).limit(limit)
     result = await session.execute(query)
     data = iter(
-        cast(Iterator, result.unique().scalars() if scalars else result.mappings())  # type: ignore # noqa
+        cast(Iterator, result.unique().scalars() if scalars else result.mappings())
     )
     return Page(
-        data=data,
-        meta={
-            "offset": offset,
-            "total_items": total_items,
-            "total_pages": total_pages,
-            "page_number": page_number,
-        },
+        data=data,  # type: ignore # Expected to be a list
+        meta=Meta(
+            offset=offset,
+            total_items=total_items,
+            total_pages=total_pages,
+            page_number=page_number,
+        ),
     )
 
 

fastapi_sqla/async_sqla.py

@@ -3,12 +3,13 @@ from contextlib import asynccontextmanager
 from typing import Annotated
 
 import structlog
-from fastapi import Depends, Request
+from fastapi import Depends, Request, Response
 from fastapi.responses import PlainTextResponse
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncEngine
 from sqlalchemy.ext.asyncio import AsyncSession as SqlaAsyncSession
 from sqlalchemy.orm.session import sessionmaker
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
 from fastapi_sqla import aws_aurora_support, aws_rds_iam_support
 from fastapi_sqla.sqla import _DEFAULT_SESSION_KEY, Base, new_engine
@@ -88,9 +89,7 @@ async def open_session(
         await session.close()
 
 
-async def add_session_to_request(
-    request: Request, call_next, key: str = _DEFAULT_SESSION_KEY
-):
+class AsyncSessionMiddleware:
     """Middleware which injects a new sqla async session into every request.
 
     Handles creation of session, as well as commit, rollback, and closing of session.
@@ -108,36 +107,58 @@ async def add_session_to_request(
         async def get_users(session: fastapi_sqla.AsyncSession):
             return await session.execute(...) # use your session here
     """
-    async with open_session(key) as session:
-        setattr(request.state, f"{_ASYNC_REQUEST_SESSION_KEY}_{key}", session)
-        response = await call_next(request)
-
-        is_dirty = bool(session.dirty or session.deleted or session.new)
-
-        # try to commit after response, so that we can return a proper 500 response
-        # and not raise a true internal server error
-        if response.status_code < 400:
-            try:
-                await session.commit()
-            except Exception:
-                logger.exception("commit failed, returning http error")
-                response = PlainTextResponse(
-                    content="Internal Server Error", status_code=500
-                )
-
-        if response.status_code >= 400:
-            # If ever a route handler returns an http exception, we do not want the
-            # session opened by current context manager to commit anything in db.
-            if is_dirty:
-                # optimistically only log if there were uncommitted changes
-                logger.warning(
-                    "http error, rolling back possibly uncommitted changes",
-                    status_code=response.status_code,
-                )
-            # since this is no-op if session is not dirty, we can always call it
-            await session.rollback()
 
-    return response
+    def __init__(self, app: ASGIApp, key: str = _DEFAULT_SESSION_KEY) -> None:
+        self.app = app
+        self.key = key
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        async with open_session(self.key) as session:
+            request = Request(scope=scope, receive=receive, send=send)
+            setattr(request.state, f"{_ASYNC_REQUEST_SESSION_KEY}_{self.key}", session)
+
+            async def send_wrapper(message: Message) -> None:
+                if message["type"] != "http.response.start":
+                    return await send(message)
+
+                response: Response | None = None
+                status_code = message["status"]
+                is_dirty = bool(session.dirty or session.deleted or session.new)
+
+                # try to commit after response, so that we can return a proper 500
+                # and not raise a true internal server error
+                if status_code < 400:
+                    try:
+                        await session.commit()
+                    except Exception:
+                        logger.exception("commit failed, returning http error")
+                        status_code = 500
+                        response = PlainTextResponse(
+                            content="Internal Server Error", status_code=500
+                        )
+
+                if status_code >= 400:
+                    # If ever a route handler returns an http exception,
+                    # we do not want the current session to commit anything in db.
+                    if is_dirty:
+                        # optimistically only log if there were uncommitted changes
+                        logger.warning(
+                            "http error, rolling back possibly uncommitted changes",
+                            status_code=status_code,
+                        )
+                    # since this is no-op if the session is not dirty,
+                    # we can always call it
+                    await session.rollback()
+
+                if response:
+                    return await response(scope, receive, send)
+
+                return await send(message)
+
+            await self.app(scope, receive, send_wrapper)
 
 
 class AsyncSessionDependency:

fastapi_sqla/aws_rds_iam_support.py

@@ -20,7 +20,8 @@ def setup(engine: Engine):
     aws_rds_iam_enabled = lc_environ.get("fastapi_sqla_aws_rds_iam_enabled") == "true"
 
     if aws_rds_iam_enabled:
-        assert boto3_installed, boto3_installed_err
+        if not boto3_installed:
+            raise ImportError(f"boto3 is required for RDS IAM : {boto3_installed_err}")
         # Cache the client at startup
         get_rds_client()
         event.listen(engine, "do_connect", set_connection_token)

fastapi_sqla/base.py

@@ -2,6 +2,7 @@ import functools
 import os
 import re
 
+from deprecated import deprecated
 from fastapi import FastAPI
 from sqlalchemy.engine import Engine
 
@@ -20,23 +21,41 @@ except ImportError as err:  # pragma: no cover
 _ENGINE_KEYS_REGEX = re.compile(r"fastapi_sqla__(?!_)(.+)(?<!_)__(?!_).+")
 
 
+async def startup():
+    engine_keys = _get_engine_keys()
+    engines = {key: sqla.new_engine(key) for key in engine_keys}
+    for key, engine in engines.items():
+        if not _is_async_dialect(engine):
+            sqla.startup(key=key)
+        else:
+            await async_sqla.startup(key=key)
+
+
+def setup_middlewares(app: FastAPI):
+    engine_keys = _get_engine_keys()
+    engines = {key: sqla.new_engine(key) for key in engine_keys}
+    for key, engine in engines.items():
+        if not _is_async_dialect(engine):
+            app.add_middleware(sqla.SessionMiddleware, key=key)
+        else:
+            app.add_middleware(async_sqla.AsyncSessionMiddleware, key=key)
+
+
+@deprecated(
+    reason="FastAPI events are deprecated. This function will be remove in the upcoming major release."  # noqa: E501
+)
 def setup(app: FastAPI):
     engine_keys = _get_engine_keys()
     engines = {key: sqla.new_engine(key) for key in engine_keys}
     for key, engine in engines.items():
         if not _is_async_dialect(engine):
             app.add_event_handler("startup", functools.partial(sqla.startup, key=key))
-            app.middleware("http")(
-                functools.partial(sqla.add_session_to_request, key=key)
-            )
+            app.add_middleware(sqla.SessionMiddleware, key=key)
         else:
-            assert has_asyncio_support, asyncio_support_err
             app.add_event_handler(
                 "startup", functools.partial(async_sqla.startup, key=key)
             )
-            app.middleware("http")(
-                functools.partial(async_sqla.add_session_to_request, key=key)
-            )
+            app.add_middleware(async_sqla.AsyncSessionMiddleware, key=key)
 
 
 def _get_engine_keys() -> set[str]:

fastapi_sqla/models.py

@@ -3,7 +3,7 @@ from typing import Generic, TypeVar
 from pydantic import BaseModel, Field
 from pydantic import __version__ as pydantic_version
 
-major, _, _ = [int(v) for v in pydantic_version.split(".")]
+major, _, _ = (int(v) for v in pydantic_version.split("."))
 is_pydantic2 = major == 2
 if is_pydantic2:
     GenericModel = BaseModel

fastapi_sqla/pagination.py

@@ -1,13 +1,13 @@
 import math
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
 from functools import singledispatch
-from typing import Annotated, Iterator, Optional, Union, cast
+from typing import Annotated, Optional, Union, cast
 
 from fastapi import Depends, Query
 from sqlalchemy.orm import Query as LegacyQuery
 from sqlalchemy.sql import Select, func, select
 
-from fastapi_sqla.models import Page
+from fastapi_sqla.models import Meta, Page
 from fastapi_sqla.sqla import _DEFAULT_SESSION_KEY, SessionDependency, SqlaSession
 
 DbQuery = Union[LegacyQuery, Select]
@@ -52,7 +52,7 @@ def paginate_query(
     limit: int,
     scalars: bool = True,
 ) -> Page:  # pragma: no cover
-    "Dispatch on registered functions based on `query` type"
+    """Dispatch on registered functions based on `query` type"""
     raise NotImplementedError(f"no paginate_query registered for type {type(query)!r}")
 
 
@@ -66,15 +66,15 @@ def _paginate_legacy(
     scalars: bool = True,
 ) -> Page:
     total_pages = math.ceil(total_items / limit)
-    page_number = offset / limit + 1
+    page_number = math.floor(offset / limit + 1)
     return Page(
-        data=query.offset(offset).limit(limit).all(),  # type: ignore
-        meta={
-            "offset": offset,
-            "total_items": total_items,
-            "total_pages": total_pages,
-            "page_number": page_number,
-        },
+        data=query.offset(offset).limit(limit).all(),
+        meta=Meta(
+            offset=offset,
+            total_items=total_items,
+            total_pages=total_pages,
+            page_number=page_number,
+        ),
     )
 
 
@@ -89,20 +89,20 @@ def _paginate(
     scalars: bool = True,
 ) -> Page:
     total_pages = math.ceil(total_items / limit)
-    page_number = offset / limit + 1
-    query = query.offset(offset).limit(limit)  # type: ignore
+    page_number = math.floor(offset / limit + 1)
+    query = query.offset(offset).limit(limit)
     result = session.execute(query)
     data = iter(
-        cast(Iterator, result.unique().scalars() if scalars else result.mappings())  # type: ignore  # noqa
+        cast(Iterator, result.unique().scalars() if scalars else result.mappings())
     )
     return Page(
-        data=data,
-        meta={
-            "offset": offset,
-            "total_items": total_items,
-            "total_pages": total_pages,
-            "page_number": page_number,
-        },
+        data=data,  # type: ignore # Expected to be a list
+        meta=Meta(
+            offset=offset,
+            total_items=total_items,
+            total_pages=total_pages,
+            page_number=page_number,
+        ),
     )
 
 

fastapi_sqla/sqla.py

@@ -2,10 +2,10 @@ import asyncio
 import os
 from collections.abc import Generator
 from contextlib import contextmanager
-from typing import Annotated, Generic, TypeVar
+from typing import Annotated
 
 import structlog
-from fastapi import Depends, Request
+from fastapi import Depends, Request, Response
 from fastapi.concurrency import contextmanager_in_threadpool
 from fastapi.responses import PlainTextResponse
 from sqlalchemy import engine_from_config, text
@@ -13,6 +13,7 @@ from sqlalchemy.engine import Engine
 from sqlalchemy.ext.declarative import DeferredReflection
 from sqlalchemy.orm.session import Session as SqlaSession
 from sqlalchemy.orm.session import sessionmaker
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
 from fastapi_sqla import aws_aurora_support, aws_rds_iam_support
 
@@ -24,7 +25,7 @@ except ImportError:
     DeclarativeBase = declarative_base()  # type: ignore
 
 try:
-    from sqlmodel import Session as SqlaSession  # type: ignore  # noqa
+    from sqlmodel import Session as SqlaSession  # type: ignore
 
 except ImportError:
     pass
@@ -110,9 +111,7 @@ def open_session(key: str = _DEFAULT_SESSION_KEY) -> Generator[SqlaSession, None
         session.close()
 
 
-async def add_session_to_request(
-    request: Request, call_next, key: str = _DEFAULT_SESSION_KEY
-):
+class SessionMiddleware:
     """Middleware which injects a new sqla session into every request.
 
     Handles creation of session, as well as commit, rollback, and closing of session.
@@ -130,49 +129,67 @@ async def add_session_to_request(
         def get_users(session: fastapi_sqla.Session):
             return session.execute(...) # use your session here
     """
-    async with contextmanager_in_threadpool(open_session(key)) as session:
-        setattr(request.state, f"{_REQUEST_SESSION_KEY}_{key}", session)
-
-        response = await call_next(request)
-
-        is_dirty = bool(session.dirty or session.deleted or session.new)
-
-        loop = asyncio.get_running_loop()
-
-        # try to commit after response, so that we can return a proper 500 response
-        # and not raise a true internal server error
-        if response.status_code < 400:
-            try:
-                await loop.run_in_executor(None, session.commit)
-            except Exception:
-                logger.exception("commit failed, returning http error")
-                response = PlainTextResponse(
-                    content="Internal Server Error", status_code=500
-                )
-
-        if response.status_code >= 400:
-            # If ever a route handler returns an http exception, we do not want the
-            # session opened by current context manager to commit anything in db.
-            if is_dirty:
-                # optimistically only log if there were uncommitted changes
-                logger.warning(
-                    "http error, rolling back possibly uncommitted changes",
-                    status_code=response.status_code,
-                )
-            # since this is no-op if session is not dirty, we can always call it
-            await loop.run_in_executor(None, session.rollback)
-
-    return response
-
-
-S = TypeVar("S", bound=SqlaSession)
 
+    def __init__(self, app: ASGIApp, key: str = _DEFAULT_SESSION_KEY) -> None:
+        self.app = app
+        self.key = key
 
-class SessionDependency(Generic[S]):
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        async with contextmanager_in_threadpool(open_session(self.key)) as session:
+            request = Request(scope=scope, receive=receive, send=send)
+            setattr(request.state, f"{_REQUEST_SESSION_KEY}_{self.key}", session)
+
+            async def send_wrapper(message: Message) -> None:
+                if message["type"] != "http.response.start":
+                    return await send(message)
+
+                response: Response | None = None
+                status_code = message["status"]
+                is_dirty = bool(session.dirty or session.deleted or session.new)
+
+                loop = asyncio.get_running_loop()
+
+                # try to commit after response, so that we can return a proper 500
+                # and not raise a true internal server error
+                if status_code < 400:
+                    try:
+                        await loop.run_in_executor(None, session.commit)
+                    except Exception:
+                        logger.exception("commit failed, returning http error")
+                        status_code = 500
+                        response = PlainTextResponse(
+                            content="Internal Server Error", status_code=status_code
+                        )
+
+                if status_code >= 400:
+                    # If ever a route handler returns an http exception,
+                    # we do not want the current session to commit anything in db.
+                    if is_dirty:
+                        # optimistically only log if there were uncommitted changes
+                        logger.warning(
+                            "http error, rolling back possibly uncommitted changes",
+                            status_code=status_code,
+                        )
+                    # since this is no-op if the session is not dirty,
+                    # we can always call it
+                    await loop.run_in_executor(None, session.rollback)
+
+                if response:
+                    return await response(scope, receive, send)
+
+                return await send(message)
+
+            await self.app(scope, receive, send_wrapper)
+
+
+class SessionDependency:
     def __init__(self, key: str = _DEFAULT_SESSION_KEY) -> None:
         self.key = key
 
-    def __call__(self, request: Request) -> S:
+    def __call__(self, request: Request) -> SqlaSession:
         """Yield the sqlalchemy session for that request.
 
         It is meant to be used as a FastAPI dependency::
@@ -197,5 +214,5 @@ class SessionDependency(Generic[S]):
             raise
 
 
-default_session_dep = SessionDependency[SqlaSession]()
+default_session_dep = SessionDependency()
 Session = Annotated[SqlaSession, Depends(default_session_dep)]

{fastapi_sqla-3.1.1.dist-info → fastapi_sqla-3.4.8.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: fastapi-sqla
-Version: 3.1.1
-Summary: SQLAlchemy extension for FastAPI with support for pagination, asyncio, and pytest, ready for production.
+Version: 3.4.8
+Summary: SQLAlchemy extension for FastAPI with support for pagination, asyncio, SQLModel, and pytest, ready for production.
 Home-page: https://github.com/dialoguemd/fastapi-sqla
 License: MIT
 Keywords: FastAPI,SQLAlchemy,asyncio,pytest,alembic
 Author: Hadrien David
 Author-email: hadrien.david@dialogue.co
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.9,<3.14
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment
 Classifier: Framework :: AsyncIO
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: SQL
 Classifier: Topic :: Internet
@@ -34,30 +35,19 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: asyncpg
 Provides-Extra: aws-rds-iam
+Provides-Extra: psycopg2
+Provides-Extra: pytest-plugin
 Provides-Extra: sqlmodel
-Provides-Extra: tests
-Requires-Dist: Faker (>=14.2.0,<15.0.0) ; extra == "tests"
-Requires-Dist: alembic (>=1.4.3,<2.0.0) ; extra == "tests"
-Requires-Dist: asgi_lifespan (>=1.0.1,<2.0.0) ; extra == "tests"
-Requires-Dist: asyncpg (>=0.28.0,<0.29.0) ; extra == "asyncpg"
-Requires-Dist: black (>=22.8.0,<23.0.0) ; extra == "tests"
-Requires-Dist: boto3 (>=1.24.74,<2.0.0) ; extra == "aws-rds-iam"
-Requires-Dist: fastapi (>=0.95.1)
-Requires-Dist: greenlet (>=1.1.3,<2.0.0) ; extra == "tests"
-Requires-Dist: httpx (>=0.23.0,<0.24.0) ; extra == "tests"
-Requires-Dist: isort (>=5.5.3,<6.0.0) ; extra == "tests"
-Requires-Dist: mypy[tests] (>=0.991,<0.992) ; extra == "tests"
-Requires-Dist: pdbpp (>=0.10.2,<0.11.0) ; extra == "tests"
-Requires-Dist: psycopg2 (>=2.8.6,<3.0.0) ; extra == "tests"
-Requires-Dist: pydantic (>=1)
-Requires-Dist: pylama (>=8.4.1,<9.0.0) ; extra == "tests"
-Requires-Dist: pytest (>=7.2.1,<8.0.0) ; extra == "tests"
-Requires-Dist: pytest-asyncio (>=0.19.0,<0.20.0) ; extra == "tests"
-Requires-Dist: pytest-cov (>=2.10.1,<3.0.0) ; extra == "tests"
-Requires-Dist: sqlalchemy (>=1.3)
-Requires-Dist: sqlmodel (>=0.0.14,<0.0.15) ; extra == "sqlmodel"
-Requires-Dist: structlog (>=20)
-Requires-Dist: tox (>=3.26.0,<4.0.0) ; extra == "tests"
+Requires-Dist: alembic (>=1.4.3,<2) ; extra == "pytest-plugin"
+Requires-Dist: asyncpg (>=0.28.0,<0.31.0) ; extra == "asyncpg"
+Requires-Dist: boto3 (>=1.24.74,<2) ; extra == "aws-rds-iam"
+Requires-Dist: deprecated (>=1.2,<2)
+Requires-Dist: fastapi (>=0.95.1,<0.116)
+Requires-Dist: psycopg2 (>=2.8.6,<3) ; extra == "psycopg2"
+Requires-Dist: pydantic (>=1,<3)
+Requires-Dist: sqlalchemy (>=1.3,<3)
+Requires-Dist: sqlmodel (>=0.0.14,<0.0.23) ; extra == "sqlmodel"
+Requires-Dist: structlog (>=20,<26)
 Project-URL: Repository, https://github.com/dialoguemd/fastapi-sqla
 Description-Content-Type: text/markdown
 
@@ -83,6 +73,8 @@ Using [pip](https://pip.pypa.io/):
 pip install fastapi-sqla
 ```
 
+Note that you need a [SQLAlchemy compatible engine](https://docs.sqlalchemy.org/en/20/core/engines.html) adapter. We test with `psycopg2` which you can install using the `psycopg2` extra.
+
 # Quick Example
 
 Assuming it runs against a DB with a table `user` with 3 columns, `id`, `name` and
@@ -90,15 +82,22 @@ unique `email`:
 
 ```python
 # main.py
+from contextlib import asynccontextmanager
 from fastapi import FastAPI, HTTPException
-from fastapi_sqla import Base, Item, Page, Paginate, Session, setup
+from fastapi_sqla import Base, Item, Page, Paginate, Session, setup_middlewares, startup
 from pydantic import BaseModel, EmailStr
 from sqlalchemy import select
 from sqlalchemy.exc import IntegrityError
 
-app = FastAPI()
 
-setup(app)
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await startup()
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+setup_middlewares(app)
 
 
 class User(Base):
@@ -203,7 +202,23 @@ And define the environment variable `sqlalchemy_url` with `postgres+asyncpg` sch
 export sqlalchemy_url=postgresql+asyncpg://postgres@localhost
 ```
 
-## Setup the app:
+## Setup the app AsyncContextManager (recommended):
+
+```python
+import fastapi_sqla
+from fastapi import FastAPI
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await fastapi_sqla.startup()
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+fastapi_sqla.setup_middlewares(app)
+```
+
+## Setup the app using startup/shutdown events (deprecated):
 
 ```python
 import fastapi_sqla
@@ -640,7 +655,7 @@ If your project uses [SQLModel], then `Session` dependency is an SQLModel sessio
 # Pytest fixtures
 
 This library provides a set of utility fixtures, through its PyTest plugin, which is
-automatically installed with the library.
+automatically installed with the library. Using the plugin requires the `pytest_plugin` extra.
 
 By default, no records are actually written to the database when running tests.
 There currently is no way to change this behaviour.
@@ -784,7 +799,7 @@ It returns the path of  `alembic.ini` configuration file. By default, it returns
 ## Setup
 
 ```bash
-$ poetry install --extras tests --extras asyncpg --extras aws_rds_iam
+$ poetry install --all-extras
 ```
 
 ## Running tests

fastapi_sqla-3.4.8.dist-info/RECORD

@@ -0,0 +1,16 @@
+fastapi_sqla/__init__.py,sha256=RRkwo9xZzidQ-k3BRXfqT0jtWm8d08w94XuOLteFCdU,1221
+fastapi_sqla/_pytest_plugin.py,sha256=IQUlj-O874Sfuth254LBrEBGCrwH3rNHST9OMZl2pIk,5411
+fastapi_sqla/async_pagination.py,sha256=3DHGUjvrpkbWMIc_BEX4GvM-_PTcn62K9z48ucTJlH0,3164
+fastapi_sqla/async_sqla.py,sha256=L5tHuYgHMpmSdGAsgxs30K7joVmMX-06NYJ7E5WaoUo,6865
+fastapi_sqla/aws_aurora_support.py,sha256=4dxLKOqDccgLwFqlz81L6f4HzrOXMZkY7Zuf4t_310U,838
+fastapi_sqla/aws_rds_iam_support.py,sha256=Uw-XaiwShMMWYKCvlSqXoxvtKMblCAvbCZ1m6BYVpJk,1257
+fastapi_sqla/base.py,sha256=40lov7wREct4q4rfXiKjlwsjFC9iFE0eDq-ghiJwGgY,2279
+fastapi_sqla/models.py,sha256=-B1xwINpTc9rEQd3KYHEC1s5s7jdVQkJ6Gy6xpmT13c,1108
+fastapi_sqla/pagination.py,sha256=1gfIGcmt1OFspbRgtJ8AZOZdFd14DGRc4FkDgyh5bJ8,4517
+fastapi_sqla/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_sqla/sqla.py,sha256=3mIGdYmyOUZaClJiHCoaZpUlzbJilH2lrMzoc2gjZN0,7335
+fastapi_sqla-3.4.8.dist-info/LICENSE,sha256=8G0-nWLqi3xRYRrtRlTE8n1mkYJcnCRoZGUhv6ZE29c,1064
+fastapi_sqla-3.4.8.dist-info/METADATA,sha256=rARChNcTpioOmQMmMGY33T4KvhC8_kD2fDz-16sch3o,20980
+fastapi_sqla-3.4.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fastapi_sqla-3.4.8.dist-info/entry_points.txt,sha256=haa0EueKcRo8-AlJTpHBMn08wMBiULNGA53nkvaDWj0,53
+fastapi_sqla-3.4.8.dist-info/RECORD,,

{fastapi_sqla-3.1.1.dist-info → fastapi_sqla-3.4.8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.6.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

fastapi_sqla-3.1.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-fastapi_sqla/__init__.py,sha256=G9bKR6L9EnLgzelE_BLnHgc1cOm0Yu0wMzwLAdyA8iE,1153
-fastapi_sqla/_pytest_plugin.py,sha256=bjPzOuwk32Zo4hoOa_bGjTGhtHGPImh3RyiORqz-J84,5430
-fastapi_sqla/async_pagination.py,sha256=r5APFbE-xpqQPF1aTG19ILOwYDhuIlHql3UF3mYZMt4,3176
-fastapi_sqla/async_sqla.py,sha256=7SXRH3DMsQvpjCQdvCBEjQhDZ4-cPAg175MlgNVBnCg,5888
-fastapi_sqla/aws_aurora_support.py,sha256=4dxLKOqDccgLwFqlz81L6f4HzrOXMZkY7Zuf4t_310U,838
-fastapi_sqla/aws_rds_iam_support.py,sha256=YSJNhrxmhGN-GVk9PLMTmQSWTKZBvuorKkhc_XaoL44,1189
-fastapi_sqla/base.py,sha256=0X7Gbt49rBHPiSFmNy5S2PT0dA4UBNnwrAesYSkaHBc,1606
-fastapi_sqla/models.py,sha256=fesW7BqkwOA4iC345dbybzcV8Kz4-kLwREo38oqy_7A,1108
-fastapi_sqla/pagination.py,sha256=uhsNRf9w2GzJQkF8eUUQZMAudPDi7tN5OCb00kz3Dn4,4515
-fastapi_sqla/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastapi_sqla/sqla.py,sha256=zAkzY07bHEnOrmP7_dwO4Gdar18qm1ZbhB1RD3AZGrA,6427
-fastapi_sqla-3.1.1.dist-info/LICENSE,sha256=8G0-nWLqi3xRYRrtRlTE8n1mkYJcnCRoZGUhv6ZE29c,1064
-fastapi_sqla-3.1.1.dist-info/METADATA,sha256=caalhTVa91W2oBq_rXUhu5xahUzINgBpq39GRlsbvxc,20905
-fastapi_sqla-3.1.1.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-fastapi_sqla-3.1.1.dist-info/entry_points.txt,sha256=haa0EueKcRo8-AlJTpHBMn08wMBiULNGA53nkvaDWj0,53
-fastapi_sqla-3.1.1.dist-info/RECORD,,