fastapi-async-sqlalchemy 0.6.1__tar.gz → 0.7.0.dev2__tar.gz

{fastapi-async-sqlalchemy-0.6.1 → fastapi_async_sqlalchemy-0.7.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-async-sqlalchemy
-Version: 0.6.1
+Version: 0.7.0.dev2
 Summary: SQLAlchemy middleware for FastAPI
 Home-page: https://github.com/h0rn3t/fastapi-async-sqlalchemy.git
 Author: Eugene Shershen
@@ -8,7 +8,7 @@ Author-email: h0rn3t.null@gmail.com
 License: MIT
 Project-URL: Code, https://github.com/h0rn3t/fastapi-async-sqlalchemy
 Project-URL: Issue tracker, https://github.com/h0rn3t/fastapi-async-sqlalchemy/issues
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.8
 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 :: Python :: Implementation :: CPython
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
@@ -50,8 +51,8 @@ Provides SQLAlchemy middleware for FastAPI using AsyncSession and async engine.
   pip install fastapi-async-sqlalchemy
 ```
 
-### Important !!!
-If you use ```sqlmodel``` install ```sqlalchemy<=1.4.41```
+
+It also works with ```sqlmodel```
 
 
 ### Examples
@@ -159,9 +160,10 @@ app.add_middleware(
 routes.py
 
 ```python
+import asyncio
+
 from fastapi import APIRouter
-from sqlalchemy import column
-from sqlalchemy import table
+from sqlalchemy import column, table, text
 
 from databases import first_db, second_db
 
@@ -179,4 +181,22 @@ async def get_files_from_first_db():
 async def get_files_from_second_db():
     result = await second_db.session.execute(foo.select())
     return result.fetchall()
+
+
+@router.get("/concurrent-queries")
+async def parallel_select():
+    async with first_db(multi_sessions=True):
+        async def execute_query(query):
+            return await first_db.session.execute(text(query))
+
+        tasks = [
+            asyncio.create_task(execute_query("SELECT 1")),
+            asyncio.create_task(execute_query("SELECT 2")),
+            asyncio.create_task(execute_query("SELECT 3")),
+            asyncio.create_task(execute_query("SELECT 4")),
+            asyncio.create_task(execute_query("SELECT 5")),
+            asyncio.create_task(execute_query("SELECT 6")),
+        ]
+
+        await asyncio.gather(*tasks)
 ```

{fastapi-async-sqlalchemy-0.6.1 → fastapi_async_sqlalchemy-0.7.0.dev2}/README.md

@@ -18,8 +18,8 @@ Provides SQLAlchemy middleware for FastAPI using AsyncSession and async engine.
   pip install fastapi-async-sqlalchemy
 ```
 
-### Important !!!
-If you use ```sqlmodel``` install ```sqlalchemy<=1.4.41```
+
+It also works with ```sqlmodel```
 
 
 ### Examples
@@ -127,9 +127,10 @@ app.add_middleware(
 routes.py
 
 ```python
+import asyncio
+
 from fastapi import APIRouter
-from sqlalchemy import column
-from sqlalchemy import table
+from sqlalchemy import column, table, text
 
 from databases import first_db, second_db
 
@@ -147,4 +148,22 @@ async def get_files_from_first_db():
 async def get_files_from_second_db():
     result = await second_db.session.execute(foo.select())
     return result.fetchall()
+
+
+@router.get("/concurrent-queries")
+async def parallel_select():
+    async with first_db(multi_sessions=True):
+        async def execute_query(query):
+            return await first_db.session.execute(text(query))
+
+        tasks = [
+            asyncio.create_task(execute_query("SELECT 1")),
+            asyncio.create_task(execute_query("SELECT 2")),
+            asyncio.create_task(execute_query("SELECT 3")),
+            asyncio.create_task(execute_query("SELECT 4")),
+            asyncio.create_task(execute_query("SELECT 5")),
+            asyncio.create_task(execute_query("SELECT 6")),
+        ]
+
+        await asyncio.gather(*tasks)
 ```

{fastapi-async-sqlalchemy-0.6.1 → fastapi_async_sqlalchemy-0.7.0.dev2}/fastapi_async_sqlalchemy/__init__.py

@@ -2,4 +2,4 @@ from fastapi_async_sqlalchemy.middleware import SQLAlchemyMiddleware, db
 
 __all__ = ["db", "SQLAlchemyMiddleware"]
 
-__version__ = "0.6.1"
+__version__ = "0.7.0.dev2"

fastapi_async_sqlalchemy-0.7.0.dev2/fastapi_async_sqlalchemy/middleware.py

@@ -0,0 +1,164 @@
+import asyncio
+from contextvars import ContextVar
+from typing import Dict, Optional, Union
+
+from sqlalchemy.engine import Engine
+from sqlalchemy.engine.url import URL
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from starlette.requests import Request
+from starlette.types import ASGIApp
+
+from fastapi_async_sqlalchemy.exceptions import MissingSessionError, SessionNotInitialisedError
+
+try:
+    from sqlalchemy.ext.asyncio import async_sessionmaker  # noqa: F811
+except ImportError:
+    from sqlalchemy.orm import sessionmaker as async_sessionmaker
+
+
+def create_middleware_and_session_proxy():
+    _Session: Optional[async_sessionmaker] = None
+    _session: ContextVar[Optional[AsyncSession]] = ContextVar("_session", default=None)
+    _multi_sessions_ctx: ContextVar[bool] = ContextVar("_multi_sessions_context", default=False)
+    _task_session_ctx: ContextVar[Optional[AsyncSession]] = ContextVar(
+        "_task_session_ctx", default=None
+    )
+    _commit_on_exit_ctx: ContextVar[bool] = ContextVar("_commit_on_exit_ctx", default=False)
+    # Usage of context vars inside closures is not recommended, since they are not properly
+    # garbage collected, but in our use case context var is created on program startup and
+    # is used throughout the whole its lifecycle.
+
+    class SQLAlchemyMiddleware(BaseHTTPMiddleware):
+        def __init__(
+            self,
+            app: ASGIApp,
+            db_url: Optional[Union[str, URL]] = None,
+            custom_engine: Optional[Engine] = None,
+            engine_args: Dict = None,
+            session_args: Dict = None,
+            commit_on_exit: bool = False,
+        ):
+            super().__init__(app)
+            self.commit_on_exit = commit_on_exit
+            engine_args = engine_args or {}
+            session_args = session_args or {}
+
+            if not custom_engine and not db_url:
+                raise ValueError("You need to pass a db_url or a custom_engine parameter.")
+            if not custom_engine:
+                engine = create_async_engine(db_url, **engine_args)
+            else:
+                engine = custom_engine
+
+            nonlocal _Session
+            _Session = async_sessionmaker(
+                engine, class_=AsyncSession, expire_on_commit=False, **session_args
+            )
+
+        async def dispatch(self, request: Request, call_next: RequestResponseEndpoint):
+            async with DBSession(commit_on_exit=self.commit_on_exit):
+                return await call_next(request)
+
+    class DBSessionMeta(type):
+        @property
+        def session(self) -> AsyncSession:
+            """Return an instance of Session local to the current async context."""
+            if _Session is None:
+                raise SessionNotInitialisedError
+
+            multi_sessions = _multi_sessions_ctx.get()
+            if multi_sessions:
+                """In this case, we need to create a new session for each task.
+                We also need to commit the session on exit if commit_on_exit is True.
+                This is useful when we need to run multiple queries in parallel.
+                For example, when we need to run multiple queries in parallel in a route handler.
+                Example:
+                ```python
+                    async with db(multi_sessions=True):
+                        async def execute_query(query):
+                            return await db.session.execute(text(query))
+
+                        tasks = [
+                            asyncio.create_task(execute_query("SELECT 1")),
+                            asyncio.create_task(execute_query("SELECT 2")),
+                            asyncio.create_task(execute_query("SELECT 3")),
+                            asyncio.create_task(execute_query("SELECT 4")),
+                            asyncio.create_task(execute_query("SELECT 5")),
+                            asyncio.create_task(execute_query("SELECT 6")),
+                        ]
+
+                        await asyncio.gather(*tasks)
+                ```
+                """
+                commit_on_exit = _commit_on_exit_ctx.get()
+                session = _task_session_ctx.get()
+                if session is None:
+                    session = _Session()
+                    _task_session_ctx.set(session)
+
+                    async def cleanup():
+                        try:
+                            if commit_on_exit:
+                                await session.commit()
+                        except Exception:
+                            await session.rollback()
+                            raise
+                        finally:
+                            await session.close()
+                            _task_session_ctx.set(None)
+
+                    task = asyncio.current_task()
+                    if task is not None:
+                        task.add_done_callback(lambda t: asyncio.create_task(cleanup()))
+                return session
+            else:
+                session = _session.get()
+                if session is None:
+                    raise MissingSessionError
+                return session
+
+    class DBSession(metaclass=DBSessionMeta):
+        def __init__(
+            self,
+            session_args: Dict = None,
+            commit_on_exit: bool = False,
+            multi_sessions: bool = False,
+        ):
+            self.token = None
+            self.multi_sessions_token = None
+            self.commit_on_exit_token = None
+            self.session_args = session_args or {}
+            self.commit_on_exit = commit_on_exit
+            self.multi_sessions = multi_sessions
+
+        async def __aenter__(self):
+            if not isinstance(_Session, async_sessionmaker):
+                raise SessionNotInitialisedError
+
+            if self.multi_sessions:
+                self.multi_sessions_token = _multi_sessions_ctx.set(True)
+                self.commit_on_exit_token = _commit_on_exit_ctx.set(self.commit_on_exit)
+            else:
+                self.token = _session.set(_Session(**self.session_args))
+            return type(self)
+
+        async def __aexit__(self, exc_type, exc_value, traceback):
+            if self.multi_sessions:
+                _multi_sessions_ctx.reset(self.multi_sessions_token)
+                _commit_on_exit_ctx.reset(self.commit_on_exit_token)
+            else:
+                session = _session.get()
+                try:
+                    if exc_type is not None:
+                        await session.rollback()
+                    elif self.commit_on_exit:
+                        await session.commit()
+                finally:
+                    await session.close()
+                    _session.reset(self.token)
+
+    return SQLAlchemyMiddleware, DBSession
+
+
+SQLAlchemyMiddleware, db = create_middleware_and_session_proxy()

{fastapi-async-sqlalchemy-0.6.1 → fastapi_async_sqlalchemy-0.7.0.dev2}/fastapi_async_sqlalchemy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-async-sqlalchemy
-Version: 0.6.1
+Version: 0.7.0.dev2
 Summary: SQLAlchemy middleware for FastAPI
 Home-page: https://github.com/h0rn3t/fastapi-async-sqlalchemy.git
 Author: Eugene Shershen
@@ -8,7 +8,7 @@ Author-email: h0rn3t.null@gmail.com
 License: MIT
 Project-URL: Code, https://github.com/h0rn3t/fastapi-async-sqlalchemy
 Project-URL: Issue tracker, https://github.com/h0rn3t/fastapi-async-sqlalchemy/issues
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.8
 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 :: Python :: Implementation :: CPython
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
@@ -50,8 +51,8 @@ Provides SQLAlchemy middleware for FastAPI using AsyncSession and async engine.
   pip install fastapi-async-sqlalchemy
 ```
 
-### Important !!!
-If you use ```sqlmodel``` install ```sqlalchemy<=1.4.41```
+
+It also works with ```sqlmodel```
 
 
 ### Examples
@@ -159,9 +160,10 @@ app.add_middleware(
 routes.py
 
 ```python
+import asyncio
+
 from fastapi import APIRouter
-from sqlalchemy import column
-from sqlalchemy import table
+from sqlalchemy import column, table, text
 
 from databases import first_db, second_db
 
@@ -179,4 +181,22 @@ async def get_files_from_first_db():
 async def get_files_from_second_db():
     result = await second_db.session.execute(foo.select())
     return result.fetchall()
+
+
+@router.get("/concurrent-queries")
+async def parallel_select():
+    async with first_db(multi_sessions=True):
+        async def execute_query(query):
+            return await first_db.session.execute(text(query))
+
+        tasks = [
+            asyncio.create_task(execute_query("SELECT 1")),
+            asyncio.create_task(execute_query("SELECT 2")),
+            asyncio.create_task(execute_query("SELECT 3")),
+            asyncio.create_task(execute_query("SELECT 4")),
+            asyncio.create_task(execute_query("SELECT 5")),
+            asyncio.create_task(execute_query("SELECT 6")),
+        ]
+
+        await asyncio.gather(*tasks)
 ```

{fastapi-async-sqlalchemy-0.6.1 → fastapi_async_sqlalchemy-0.7.0.dev2}/setup.py

@@ -29,7 +29,7 @@ setup(
     python_requires=">=3.7",
     install_requires=["starlette>=0.13.6", "SQLAlchemy>=1.4.19"],
     classifiers=[
-        "Development Status :: 4 - Beta",
+        "Development Status :: 5 - Production/Stable",
         "Environment :: Web Environment",
         "Framework :: AsyncIO",
         "Intended Audience :: Developers",
@@ -40,6 +40,7 @@ setup(
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
         "Programming Language :: Python :: 3 :: Only",
         "Programming Language :: Python :: Implementation :: CPython",
         "Topic :: Internet :: WWW/HTTP :: HTTP Servers",

{fastapi-async-sqlalchemy-0.6.1 → fastapi_async_sqlalchemy-0.7.0.dev2}/tests/test_session.py

@@ -1,4 +1,7 @@
+import asyncio
+
 import pytest
+from sqlalchemy import text
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
 from starlette.middleware.base import BaseHTTPMiddleware
@@ -148,3 +151,50 @@ async def test_db_context_session_args(app, db, SQLAlchemyMiddleware, commit_on_
     session_args = {"expire_on_commit": False}
     async with db(session_args=session_args):
         db.session
+
+
+@pytest.mark.asyncio
+async def test_multi_sessions(app, db, SQLAlchemyMiddleware):
+    app.add_middleware(SQLAlchemyMiddleware, db_url=db_url)
+
+    async with db(multi_sessions=True):
+
+        async def execute_query(query):
+            return await db.session.execute(text(query))
+
+        tasks = [
+            asyncio.create_task(execute_query("SELECT 1")),
+            asyncio.create_task(execute_query("SELECT 2")),
+            asyncio.create_task(execute_query("SELECT 3")),
+            asyncio.create_task(execute_query("SELECT 4")),
+            asyncio.create_task(execute_query("SELECT 5")),
+            asyncio.create_task(execute_query("SELECT 6")),
+        ]
+
+        res = await asyncio.gather(*tasks)
+        assert len(res) == 6
+
+
+@pytest.mark.asyncio
+async def test_concurrent_inserts(app, db, SQLAlchemyMiddleware):
+    app.add_middleware(SQLAlchemyMiddleware, db_url=db_url)
+
+    async with db(multi_sessions=True, commit_on_exit=True):
+        await db.session.execute(
+            text("CREATE TABLE IF NOT EXISTS my_model (id INTEGER PRIMARY KEY, value TEXT)")
+        )
+
+        async def insert_data(value):
+            await db.session.execute(
+                text("INSERT INTO my_model (value) VALUES (:value)"), {"value": value}
+            )
+            await db.session.flush()
+
+        tasks = [asyncio.create_task(insert_data(f"value_{i}")) for i in range(10)]
+
+        result_ids = await asyncio.gather(*tasks)
+        assert len(result_ids) == 10
+
+        records = await db.session.execute(text("SELECT * FROM my_model"))
+        records = records.scalars().all()
+        assert len(records) == 10

fastapi-async-sqlalchemy-0.6.1/fastapi_async_sqlalchemy/middleware.py

@@ -1,100 +0,0 @@
-from contextvars import ContextVar
-from typing import Dict, Optional, Union
-
-from sqlalchemy.engine import Engine
-from sqlalchemy.engine.url import URL
-from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
-from starlette.requests import Request
-from starlette.types import ASGIApp
-
-from fastapi_async_sqlalchemy.exceptions import MissingSessionError, SessionNotInitialisedError
-
-try:
-    from sqlalchemy.ext.asyncio import async_sessionmaker
-except ImportError:
-    from sqlalchemy.orm import sessionmaker as async_sessionmaker
-
-
-def create_middleware_and_session_proxy():
-    _Session: Optional[async_sessionmaker] = None
-    # Usage of context vars inside closures is not recommended, since they are not properly
-    # garbage collected, but in our use case context var is created on program startup and
-    # is used throughout the whole its lifecycle.
-    _session: ContextVar[Optional[AsyncSession]] = ContextVar("_session", default=None)
-
-    class SQLAlchemyMiddleware(BaseHTTPMiddleware):
-        def __init__(
-            self,
-            app: ASGIApp,
-            db_url: Optional[Union[str, URL]] = None,
-            custom_engine: Optional[Engine] = None,
-            engine_args: Dict = None,
-            session_args: Dict = None,
-            commit_on_exit: bool = False,
-        ):
-            super().__init__(app)
-            self.commit_on_exit = commit_on_exit
-            engine_args = engine_args or {}
-            session_args = session_args or {}
-
-            if not custom_engine and not db_url:
-                raise ValueError("You need to pass a db_url or a custom_engine parameter.")
-            if not custom_engine:
-                engine = create_async_engine(db_url, **engine_args)
-            else:
-                engine = custom_engine
-
-            nonlocal _Session
-            _Session = async_sessionmaker(
-                engine, class_=AsyncSession, expire_on_commit=False, **session_args
-            )
-
-        async def dispatch(self, request: Request, call_next: RequestResponseEndpoint):
-            async with DBSession(commit_on_exit=self.commit_on_exit):
-                return await call_next(request)
-
-    class DBSessionMeta(type):
-        @property
-        def session(self) -> AsyncSession:
-            """Return an instance of Session local to the current async context."""
-            if _Session is None:
-                raise SessionNotInitialisedError
-
-            session = _session.get()
-            if session is None:
-                raise MissingSessionError
-
-            return session
-
-    class DBSession(metaclass=DBSessionMeta):
-        def __init__(self, session_args: Dict = None, commit_on_exit: bool = False):
-            self.token = None
-            self.session_args = session_args or {}
-            self.commit_on_exit = commit_on_exit
-
-        async def __aenter__(self):
-            if not isinstance(_Session, async_sessionmaker):
-                raise SessionNotInitialisedError
-
-            self.token = _session.set(_Session(**self.session_args))  # type: ignore
-            return type(self)
-
-        async def __aexit__(self, exc_type, exc_value, traceback):
-            session = _session.get()
-
-            try:
-                if exc_type is not None:
-                    await session.rollback()
-                elif (
-                    self.commit_on_exit
-                ):  # Note: Changed this to elif to avoid commit after rollback
-                    await session.commit()
-            finally:
-                await session.close()
-                _session.reset(self.token)
-
-    return SQLAlchemyMiddleware, DBSession
-
-
-SQLAlchemyMiddleware, db = create_middleware_and_session_proxy()