fastapi-sqla 3.3.0__py3-none-any.whl → 3.4.1__py3-none-any.whl

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/base.py

@@ -36,13 +36,9 @@ def setup_middlewares(app: FastAPI):
     engines = {key: sqla.new_engine(key) for key in engine_keys}
     for key, engine in engines.items():
         if not _is_async_dialect(engine):
-            app.middleware("http")(
-                functools.partial(sqla.add_session_to_request, key=key)
-            )
+            app.add_middleware(sqla.SessionMiddleware, key=key)
         else:
-            app.middleware("http")(
-                functools.partial(async_sqla.add_session_to_request, key=key)
-            )
+            app.add_middleware(async_sqla.AsyncSessionMiddleware, key=key)
 
 
 @deprecated(
@@ -54,16 +50,12 @@ def setup(app: FastAPI):
     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:
             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/sqla.py

@@ -5,7 +5,7 @@ from contextlib import contextmanager
 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
 
@@ -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,39 +129,60 @@ 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
+
+    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 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:

{fastapi_sqla-3.3.0.dist-info → fastapi_sqla-3.4.1.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: fastapi-sqla
-Version: 3.3.0
+Version: 3.4.1
 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.13
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment
 Classifier: Framework :: AsyncIO
@@ -35,29 +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: boto3 (>=1.24.74,<2.0.0) ; extra == "aws-rds-iam"
-Requires-Dist: deprecated (>=1.2)
-Requires-Dist: fastapi (>=0.95.1)
-Requires-Dist: greenlet (>=3.0.3,<4.0.0) ; extra == "tests"
-Requires-Dist: httpx (>=0.23.0,<0.24.0) ; extra == "tests"
-Requires-Dist: mypy[tests] (>=1.0.0,<2.0.0) ; 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: 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: ruff (>=0.4.5,<0.5.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.30.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.112)
+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.20) ; extra == "sqlmodel"
+Requires-Dist: structlog (>=20,<25)
 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
@@ -663,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.
@@ -807,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.3.0.dist-info → fastapi_sqla-3.4.1.dist-info}/RECORD

@@ -1,16 +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=7SXRH3DMsQvpjCQdvCBEjQhDZ4-cPAg175MlgNVBnCg,5888
+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=8XHIKO8sBOmnRvCsOYRWhg5Y-XYqobM5DypeIMvJTFs,2501
+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=irHuZaun027o9WJrdcZPavCN2vXNHupCWYhU5Dx-AqE,6348
-fastapi_sqla-3.3.0.dist-info/LICENSE,sha256=8G0-nWLqi3xRYRrtRlTE8n1mkYJcnCRoZGUhv6ZE29c,1064
-fastapi_sqla-3.3.0.dist-info/METADATA,sha256=sNlfIYlzk2w8fmVxJh8jsOinZLJHrmOgWMLCZi4DV4o,21391
-fastapi_sqla-3.3.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-fastapi_sqla-3.3.0.dist-info/entry_points.txt,sha256=haa0EueKcRo8-AlJTpHBMn08wMBiULNGA53nkvaDWj0,53
-fastapi_sqla-3.3.0.dist-info/RECORD,,
+fastapi_sqla/sqla.py,sha256=3mIGdYmyOUZaClJiHCoaZpUlzbJilH2lrMzoc2gjZN0,7335
+fastapi_sqla-3.4.1.dist-info/LICENSE,sha256=8G0-nWLqi3xRYRrtRlTE8n1mkYJcnCRoZGUhv6ZE29c,1064
+fastapi_sqla-3.4.1.dist-info/METADATA,sha256=kzyKdVOQiyO78Xts1ZhGUw8p2r6tRfLJxsJ0Exu1FyA,20980
+fastapi_sqla-3.4.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fastapi_sqla-3.4.1.dist-info/entry_points.txt,sha256=haa0EueKcRo8-AlJTpHBMn08wMBiULNGA53nkvaDWj0,53
+fastapi_sqla-3.4.1.dist-info/RECORD,,