fastapi-async-sqlalchemy 0.7.1.post1__tar.gz → 0.7.1.post3__tar.gz

{fastapi_async_sqlalchemy-0.7.1.post1 → fastapi_async_sqlalchemy-0.7.1.post3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-async-sqlalchemy
-Version: 0.7.1.post1
+Version: 0.7.1.post3
 Summary: SQLAlchemy middleware for FastAPI
 Home-page: https://github.com/h0rn3t/fastapi-async-sqlalchemy.git
 Author: Eugene Shershen

{fastapi_async_sqlalchemy-0.7.1.post1 → fastapi_async_sqlalchemy-0.7.1.post3}/fastapi_async_sqlalchemy/__init__.py

@@ -19,4 +19,4 @@ __all__ = [
     "DBSessionType",
 ]
 
-__version__ = "0.7.1.post1"
+__version__ = "0.7.1.post3"

{fastapi_async_sqlalchemy-0.7.1.post1 → fastapi_async_sqlalchemy-0.7.1.post3}/fastapi_async_sqlalchemy/middleware.py

@@ -1,6 +1,5 @@
 import asyncio
 from contextvars import ContextVar
-from dataclasses import dataclass, field
 from typing import Optional, Union
 
 from sqlalchemy.engine.url import URL
@@ -27,24 +26,14 @@ except ImportError:
     DefaultAsyncSession: type[AsyncSession] = AsyncSession  # type: ignore
 
 
-@dataclass(slots=True)
-class MultiSessionState:
-    """State for multi_sessions mode."""
-
-    tracked: set[AsyncSession] = field(default_factory=set)
-    task_sessions: dict[int, AsyncSession] = field(default_factory=dict)
-    cleanup_tasks: list[asyncio.Task] = field(default_factory=list)
-    parent_task_id: int = 0
-    commit_on_exit: bool = False
-
-
 def create_middleware_and_session_proxy() -> tuple:
     _Session: Optional[async_sessionmaker] = None
     _session: ContextVar[Optional[AsyncSession]] = ContextVar("_session", default=None)
-    _multi_state: ContextVar[Optional[MultiSessionState]] = ContextVar("_multi_state", default=None)
+    _multi_sessions_ctx: ContextVar[bool] = ContextVar("_multi_sessions_context", default=False)
+    _commit_on_exit_ctx: ContextVar[bool] = ContextVar("_commit_on_exit_ctx", default=False)
 
     class _SQLAlchemyMiddleware(BaseHTTPMiddleware):
-        __test__ = False  # Prevent pytest from collecting this as a test class
+        __test__ = False
 
         def __init__(
             self,
@@ -86,48 +75,24 @@ def create_middleware_and_session_proxy() -> tuple:
             if _Session is None:
                 raise SessionNotInitialisedError
 
-            state = _multi_state.get()
-            if state is not None:
-                task = asyncio.current_task()
-                if task is None:
-                    raise RuntimeError("Cannot get current task")
-                task_id = id(task)
-
-                if task_id in state.task_sessions:
-                    return state.task_sessions[task_id]
-
+            multi_sessions = _multi_sessions_ctx.get()
+            if multi_sessions:
+                commit_on_exit = _commit_on_exit_ctx.get()
                 session = _Session()
-                state.task_sessions[task_id] = session
-                state.tracked.add(session)
-
-                # Add cleanup callback only for child tasks
-                if task_id != state.parent_task_id:
-
-                    def cleanup_callback(_task):
-                        try:
-                            loop = asyncio.get_running_loop()
-                            if loop.is_closed():
-                                return
-                        except RuntimeError:
-                            return
-
-                        async def cleanup():
-                            try:
-                                if state.commit_on_exit:
-                                    try:
-                                        await session.commit()
-                                    except Exception:
-                                        await session.rollback()
-                            finally:
-                                await session.close()
-                                state.tracked.discard(session)
-                                state.task_sessions.pop(task_id, None)
-
-                        t = loop.create_task(cleanup())
-                        state.cleanup_tasks.append(t)
-
-                    task.add_done_callback(cleanup_callback)
 
+                async def cleanup():
+                    try:
+                        if commit_on_exit:
+                            await session.commit()
+                    except Exception:
+                        await session.rollback()
+                        raise
+                    finally:
+                        await session.close()
+
+                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()
@@ -143,7 +108,8 @@ def create_middleware_and_session_proxy() -> tuple:
             multi_sessions: bool = False,
         ):
             self.token = None
-            self.multi_state_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
@@ -153,54 +119,23 @@ def create_middleware_and_session_proxy() -> tuple:
                 raise SessionNotInitialisedError
 
             if self.multi_sessions:
-                state = MultiSessionState(
-                    parent_task_id=id(asyncio.current_task()),
-                    commit_on_exit=self.commit_on_exit,
-                )
-                self.multi_state_token = _multi_state.set(state)
+                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:
-                state = _multi_state.get()
-
-                # Wait for cleanup tasks
-                if state.cleanup_tasks:
-                    await asyncio.sleep(0)
-                    await asyncio.gather(*state.cleanup_tasks, return_exceptions=True)
-
-                # Clean up remaining sessions
-                for session in list(state.tracked):
-                    try:
-                        if exc_type is not None:
-                            await session.rollback()
-                        elif self.commit_on_exit:
-                            try:
-                                await session.commit()
-                            except Exception:
-                                await session.rollback()
-                    except Exception:
-                        pass
-                    finally:
-                        try:
-                            await session.close()
-                        except Exception:
-                            pass
-
-                _multi_state.reset(self.multi_state_token)
+                _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:
-                        try:
-                            await session.commit()
-                        except Exception:
-                            await session.rollback()
-                            raise
+                        await session.commit()
                 finally:
                     await session.close()
                     _session.reset(self.token)

{fastapi_async_sqlalchemy-0.7.1.post1 → fastapi_async_sqlalchemy-0.7.1.post3}/fastapi_async_sqlalchemy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-async-sqlalchemy
-Version: 0.7.1.post1
+Version: 0.7.1.post3
 Summary: SQLAlchemy middleware for FastAPI
 Home-page: https://github.com/h0rn3t/fastapi-async-sqlalchemy.git
 Author: Eugene Shershen

{fastapi_async_sqlalchemy-0.7.1.post1 → fastapi_async_sqlalchemy-0.7.1.post3}/fastapi_async_sqlalchemy.egg-info/SOURCES.txt

@@ -13,15 +13,17 @@ fastapi_async_sqlalchemy.egg-info/not-zip-safe
 fastapi_async_sqlalchemy.egg-info/requires.txt
 fastapi_async_sqlalchemy.egg-info/top_level.txt
 tests/test_additional_coverage.py
+tests/test_backward_compat_gather.py
+tests/test_concurrent_queries.py
 tests/test_coverage_boost.py
 tests/test_coverage_improvements.py
 tests/test_custom_engine_branch.py
 tests/test_edge_cases_coverage.py
 tests/test_import_fallback_simulation.py
 tests/test_import_fallbacks.py
+tests/test_import_without_sqlmodel.py
 tests/test_maximum_coverage.py
-tests/test_multi_sessions_cleanup.py
-tests/test_multisession_pool.py
 tests/test_session.py
+tests/test_single_session_no_gather.py
 tests/test_sqlmodel.py
 tests/test_type_hints_compatibility.py

fastapi_async_sqlalchemy-0.7.1.post3/tests/test_backward_compat_gather.py

@@ -0,0 +1,213 @@
+"""Test backward compatibility for asyncio.gather() without multi_sessions flag.
+
+This test verifies that after the fix, the old code pattern works without
+requiring multi_sessions=True explicitly.
+"""
+
+import asyncio
+
+import pytest
+from sqlalchemy import text
+
+db_url = "sqlite+aiosqlite://"
+
+
+@pytest.mark.asyncio
+async def test_gather_works_without_multi_sessions_flag(app, db, SQLAlchemyMiddleware):
+    """
+    Verify that asyncio.gather() works in normal mode (without multi_sessions=True).
+
+    This is the backward compatibility fix - users shouldn't need to change their code.
+    """
+    app.add_middleware(SQLAlchemyMiddleware, db_url=db_url)
+
+    async with db(commit_on_exit=True):
+        await db.session.execute(
+            text("CREATE TABLE IF NOT EXISTS compat_test (id INTEGER PRIMARY KEY, value TEXT)")
+        )
+        for i in range(20):
+            await db.session.execute(
+                text("INSERT INTO compat_test (value) VALUES (:value)"),
+                {"value": f"value_{i}"},
+            )
+
+    # OLD CODE PATTERN - should work now without multi_sessions=True
+    async with db():
+        count_stmt = text("SELECT COUNT(*) FROM compat_test")
+        data_stmt = text("SELECT * FROM compat_test LIMIT 5")
+
+        # This should work! Each parallel query gets its own session
+        count_result, data_result = await asyncio.gather(
+            db.session.execute(count_stmt),
+            db.session.execute(data_stmt),
+        )
+
+        count = count_result.scalar()
+        data = data_result.fetchall()
+
+        assert count == 20
+        assert len(data) == 5
+
+    print("✅ Backward compatibility preserved: asyncio.gather() works without multi_sessions!")
+
+
+@pytest.mark.asyncio
+async def test_gather_multiple_queries_parallel(app, db, SQLAlchemyMiddleware):
+    """
+    Test that multiple parallel queries work correctly.
+    """
+    app.add_middleware(SQLAlchemyMiddleware, db_url=db_url)
+
+    async with db(commit_on_exit=True):
+        await db.session.execute(
+            text("CREATE TABLE IF NOT EXISTS parallel_test (id INTEGER PRIMARY KEY, status TEXT)")
+        )
+        for i in range(100):
+            await db.session.execute(
+                text("INSERT INTO parallel_test (status) VALUES (:status)"),
+                {"status": "active" if i % 3 == 0 else "inactive"},
+            )
+
+    # Multiple parallel queries without multi_sessions=True
+    async with db():
+        stmt1 = text("SELECT COUNT(*) FROM parallel_test WHERE status = 'active'")
+        stmt2 = text("SELECT COUNT(*) FROM parallel_test WHERE status = 'inactive'")
+        stmt3 = text("SELECT * FROM parallel_test LIMIT 10")
+
+        r1, r2, r3 = await asyncio.gather(
+            db.session.execute(stmt1),
+            db.session.execute(stmt2),
+            db.session.execute(stmt3),
+        )
+
+        active_count = r1.scalar()
+        inactive_count = r2.scalar()
+        data = r3.fetchall()
+
+        assert active_count == 34  # 100 / 3 rounded up
+        assert inactive_count == 66
+        assert len(data) == 10
+
+
+@pytest.mark.asyncio
+async def test_production_pattern_without_changes(app, db, SQLAlchemyMiddleware):
+    """
+    Verify the EXACT production pattern from the error report works.
+
+    This is the pattern from /app/api/repository/routes.py:186
+    """
+    app.add_middleware(SQLAlchemyMiddleware, db_url=db_url)
+
+    async with db(commit_on_exit=True):
+        await db.session.execute(
+            text("""
+                CREATE TABLE IF NOT EXISTS processes (
+                    id INTEGER PRIMARY KEY,
+                    name TEXT NOT NULL,
+                    status TEXT,
+                    created_at TEXT
+                )
+            """)
+        )
+        for i in range(100):
+            await db.session.execute(
+                text(
+                    """INSERT INTO
+                           processes (name, status, created_at)
+                       VALUES (:name, :status, :created_at)
+                    """
+                ),
+                {
+                    "name": f"process_{i}",
+                    "status": "running" if i % 2 == 0 else "stopped",
+                    "created_at": "2025-01-01T00:00:00",
+                },
+            )
+
+    # EXACT PRODUCTION CODE - should work now!
+    async with db():
+        count_stmt = text("SELECT COUNT(*) FROM processes WHERE status = :status")
+        processes_stmt = text(
+            "SELECT * FROM processes WHERE status = :status "
+            "ORDER BY created_at DESC LIMIT :limit OFFSET :offset"
+        )
+
+        count_stmt = count_stmt.bindparams(status="running")
+        processes_stmt = processes_stmt.bindparams(status="running", limit=10, offset=0)
+
+        # This is line 186 from production - should work without any changes!
+        total_result, processes_result = await asyncio.gather(
+            db.session.execute(count_stmt),
+            db.session.execute(processes_stmt),
+        )
+
+        total = total_result.scalar()
+        processes = processes_result.fetchall()
+
+        assert total == 50
+        assert len(processes) == 10
+
+    print("✅ Production code pattern works without any changes!")
+
+
+@pytest.mark.asyncio
+async def test_commit_on_exit_with_parallel_queries(app, db, SQLAlchemyMiddleware):
+    """
+    Verify that commit_on_exit works correctly with parallel queries.
+    """
+    app.add_middleware(SQLAlchemyMiddleware, db_url=db_url)
+
+    # Create table first
+    async with db(commit_on_exit=True):
+        await db.session.execute(
+            text("CREATE TABLE IF NOT EXISTS commit_test (id INTEGER PRIMARY KEY, value TEXT)")
+        )
+
+    # Insert data with parallel queries and commit_on_exit
+    async with db(commit_on_exit=True):
+        # These should all be committed automatically
+        await asyncio.gather(
+            db.session.execute(text("INSERT INTO commit_test (value) VALUES ('a')")),
+            db.session.execute(text("INSERT INTO commit_test (value) VALUES ('b')")),
+            db.session.execute(text("INSERT INTO commit_test (value) VALUES ('c')")),
+        )
+
+    # Verify data was committed
+    async with db():
+        result = await db.session.execute(text("SELECT COUNT(*) FROM commit_test"))
+        count = result.scalar()
+        assert count == 3
+
+    print("✅ commit_on_exit works correctly with parallel queries!")
+
+
+@pytest.mark.asyncio
+async def test_rollback_on_error_with_parallel_queries(app, db, SQLAlchemyMiddleware):
+    """
+    Verify that rollback works correctly when error occurs in parallel queries.
+    """
+    app.add_middleware(SQLAlchemyMiddleware, db_url=db_url)
+
+    async with db(commit_on_exit=True):
+        await db.session.execute(
+            text("CREATE TABLE IF NOT EXISTS rollback_test (id INTEGER PRIMARY KEY, value TEXT)")
+        )
+
+    # Try to insert with error - should rollback all
+    try:
+        async with db(commit_on_exit=True):
+            await db.session.execute(
+                text("INSERT INTO rollback_test (value) VALUES ('should_rollback')")
+            )
+            # Force an error
+            raise RuntimeError("Simulated error")
+    except RuntimeError:
+        pass
+
+    # Verify data was rolled back
+    async with db():
+        result = await db.session.execute(text("SELECT COUNT(*) FROM rollback_test"))
+        count = result.scalar()
+        assert count == 0
+
+    print("✅ Rollback works correctly on error!")