fastapi-async-sqlalchemy 0.7.0.dev5__tar.gz → 0.7.1.post1__tar.gz

{fastapi_async_sqlalchemy-0.7.0.dev5 → fastapi_async_sqlalchemy-0.7.1.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-async-sqlalchemy
-Version: 0.7.0.dev5
+Version: 0.7.1.post1
 Summary: SQLAlchemy middleware for FastAPI
 Home-page: https://github.com/h0rn3t/fastapi-async-sqlalchemy.git
 Author: Eugene Shershen
@@ -14,8 +14,6 @@ Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.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
@@ -25,7 +23,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: starlette>=0.13.6

fastapi_async_sqlalchemy-0.7.1.post1/fastapi_async_sqlalchemy/__init__.py

@@ -0,0 +1,22 @@
+from fastapi_async_sqlalchemy.middleware import (
+    SQLAlchemyMiddleware,
+    create_middleware_and_session_proxy,
+    db,
+)
+
+# Export DBSessionMeta type for type hints (Issue #18)
+# Note: DBSessionMeta is the metaclass of db, created dynamically.
+# It can be used in runtime type checks (isinstance, type(db) is DBSessionMeta)
+# but mypy may show warnings when used in type annotations due to its dynamic nature.
+DBSessionMeta = type(db)
+DBSessionType = DBSessionMeta  # Alternative name for backwards compatibility
+
+__all__ = [
+    "db",
+    "SQLAlchemyMiddleware",
+    "create_middleware_and_session_proxy",
+    "DBSessionMeta",
+    "DBSessionType",
+]
+
+__version__ = "0.7.1.post1"

fastapi_async_sqlalchemy-0.7.1.post1/fastapi_async_sqlalchemy/middleware.py

@@ -0,0 +1,211 @@
+import asyncio
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from typing import Optional, Union
+
+from sqlalchemy.engine.url import URL
+from sqlalchemy.ext.asyncio import AsyncEngine, 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  # type: ignore
+
+try:
+    from sqlmodel.ext.asyncio.session import AsyncSession as SQLModelAsyncSession
+
+    DefaultAsyncSession: type[AsyncSession] = SQLModelAsyncSession  # type: ignore
+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)
+
+    class _SQLAlchemyMiddleware(BaseHTTPMiddleware):
+        __test__ = False  # Prevent pytest from collecting this as a test class
+
+        def __init__(
+            self,
+            app: ASGIApp,
+            db_url: Optional[Union[str, URL]] = None,
+            custom_engine: Optional[AsyncEngine] = None,
+            engine_args: Optional[dict] = None,
+            session_args: Optional[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 custom_engine:
+                engine = custom_engine
+            else:
+                engine = create_async_engine(db_url, **engine_args)
+
+            nonlocal _Session
+            _Session = async_sessionmaker(
+                engine,
+                class_=DefaultAsyncSession,
+                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
+
+            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]
+
+                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)
+
+                return session
+            else:
+                session = _session.get()
+                if session is None:
+                    raise MissingSessionError
+                return session
+
+    class DBSession(metaclass=DBSessionMeta):
+        def __init__(
+            self,
+            session_args: Optional[dict] = None,
+            commit_on_exit: bool = False,
+            multi_sessions: bool = False,
+        ):
+            self.token = None
+            self.multi_state_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:
+                state = MultiSessionState(
+                    parent_task_id=id(asyncio.current_task()),
+                    commit_on_exit=self.commit_on_exit,
+                )
+                self.multi_state_token = _multi_state.set(state)
+            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)
+            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
+                finally:
+                    await session.close()
+                    _session.reset(self.token)
+
+    return _SQLAlchemyMiddleware, DBSession
+
+
+SQLAlchemyMiddleware, db = create_middleware_and_session_proxy()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-async-sqlalchemy
-Version: 0.7.0.dev5
+Version: 0.7.1.post1
 Summary: SQLAlchemy middleware for FastAPI
 Home-page: https://github.com/h0rn3t/fastapi-async-sqlalchemy.git
 Author: Eugene Shershen
@@ -14,8 +14,6 @@ Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.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
@@ -25,7 +23,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: starlette>=0.13.6

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

@@ -14,5 +14,14 @@ fastapi_async_sqlalchemy.egg-info/requires.txt
 fastapi_async_sqlalchemy.egg-info/top_level.txt
 tests/test_additional_coverage.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_maximum_coverage.py
+tests/test_multi_sessions_cleanup.py
+tests/test_multisession_pool.py
 tests/test_session.py
-tests/test_sqlmodel.py
+tests/test_sqlmodel.py
+tests/test_type_hints_compatibility.py

{fastapi_async_sqlalchemy-0.7.0.dev5 → fastapi_async_sqlalchemy-0.7.1.post1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.ruff]
 line-length = 100
-target-version = "py37"
+target-version = "py39"
 exclude = [
     ".git",
     ".venv",
@@ -31,3 +31,9 @@ line-ending = "auto"
 [tool.ruff.lint.isort]
 combine-as-imports = true
 split-on-trailing-comma = true
+
+[tool.pytest.ini_options]
+filterwarnings = [
+    "ignore::DeprecationWarning",
+    "ignore:The garbage collector is trying to clean up:sqlalchemy.exc.SAWarning",
+]

{fastapi_async_sqlalchemy-0.7.0.dev5 → fastapi_async_sqlalchemy-0.7.1.post1}/setup.py

@@ -26,7 +26,7 @@ setup(
     packages=["fastapi_async_sqlalchemy"],
     package_data={"fastapi_async_sqlalchemy": ["py.typed"]},
     zip_safe=False,
-    python_requires=">=3.7",
+    python_requires=">=3.9",
     install_requires=["starlette>=0.13.6", "SQLAlchemy>=1.4.19"],
     classifiers=[
         "Development Status :: 5 - Production/Stable",
@@ -35,8 +35,6 @@ setup(
         "Intended Audience :: Developers",
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",

{fastapi_async_sqlalchemy-0.7.0.dev5 → fastapi_async_sqlalchemy-0.7.1.post1}/tests/test_additional_coverage.py

@@ -1,23 +1,24 @@
 """
 Additional tests to reach target coverage of 97.22%
 """
-import pytest
+
 from fastapi import FastAPI
 
 
 def test_commit_on_exit_parameter():
     """Test commit_on_exit parameter in middleware initialization"""
     from sqlalchemy.ext.asyncio import create_async_engine
+
     from fastapi_async_sqlalchemy.middleware import create_middleware_and_session_proxy
-    
+
     SQLAlchemyMiddleware, db = create_middleware_and_session_proxy()
     app = FastAPI()
-    
+
     # Test commit_on_exit=True
     custom_engine = create_async_engine("sqlite+aiosqlite://")
     middleware = SQLAlchemyMiddleware(app, custom_engine=custom_engine, commit_on_exit=True)
     assert middleware.commit_on_exit is True
-    
+
     # Test commit_on_exit=False (default)
     middleware2 = SQLAlchemyMiddleware(app, custom_engine=custom_engine, commit_on_exit=False)
     assert middleware2.commit_on_exit is False
@@ -26,33 +27,30 @@ def test_commit_on_exit_parameter():
 def test_exception_classes_simple():
     """Test exception classes are properly defined"""
     from fastapi_async_sqlalchemy.exceptions import MissingSessionError, SessionNotInitialisedError
-    
+
     # Test exception instantiation without parameters
     missing_error = MissingSessionError()
     assert isinstance(missing_error, Exception)
-    
+
     init_error = SessionNotInitialisedError()
     assert isinstance(init_error, Exception)
 
 
 def test_middleware_properties():
     """Test middleware properties and methods"""
-    from fastapi_async_sqlalchemy.middleware import create_middleware_and_session_proxy
-    from sqlalchemy.ext.asyncio import create_async_engine
     from fastapi import FastAPI
-    
+    from sqlalchemy.ext.asyncio import create_async_engine
+
+    from fastapi_async_sqlalchemy.middleware import create_middleware_and_session_proxy
+
     SQLAlchemyMiddleware, db = create_middleware_and_session_proxy()
     app = FastAPI()
-    
+
     # Test middleware properties
     custom_engine = create_async_engine("sqlite+aiosqlite://")
-    middleware = SQLAlchemyMiddleware(
-        app, 
-        custom_engine=custom_engine, 
-        commit_on_exit=True
-    )
-    
-    assert hasattr(middleware, 'commit_on_exit')
+    middleware = SQLAlchemyMiddleware(app, custom_engine=custom_engine, commit_on_exit=True)
+
+    assert hasattr(middleware, "commit_on_exit")
     assert middleware.commit_on_exit is True
 
 
@@ -60,41 +58,48 @@ def test_basic_imports():
     """Test basic imports and module structure"""
     # Test main module imports
     from fastapi_async_sqlalchemy import SQLAlchemyMiddleware, db
+
     assert SQLAlchemyMiddleware is not None
     assert db is not None
-    
+
     # Test exception imports
     from fastapi_async_sqlalchemy.exceptions import MissingSessionError, SessionNotInitialisedError
-    assert MissingSessionError is not None 
+
+    assert MissingSessionError is not None
     assert SessionNotInitialisedError is not None
-    
+
     # Test middleware module imports
-    from fastapi_async_sqlalchemy.middleware import create_middleware_and_session_proxy, DefaultAsyncSession
+    from fastapi_async_sqlalchemy.middleware import (
+        DefaultAsyncSession,
+        create_middleware_and_session_proxy,
+    )
+
     assert create_middleware_and_session_proxy is not None
     assert DefaultAsyncSession is not None
 
 
 def test_middleware_factory_different_instances():
     """Test creating multiple middleware/db instances"""
-    from fastapi_async_sqlalchemy.middleware import create_middleware_and_session_proxy
     from fastapi import FastAPI
     from sqlalchemy.ext.asyncio import create_async_engine
-    
+
+    from fastapi_async_sqlalchemy.middleware import create_middleware_and_session_proxy
+
     # Create first instance
     SQLAlchemyMiddleware1, db1 = create_middleware_and_session_proxy()
-    
+
     # Create second instance
     SQLAlchemyMiddleware2, db2 = create_middleware_and_session_proxy()
-    
+
     # They should be different instances
     assert SQLAlchemyMiddleware1 is not SQLAlchemyMiddleware2
     assert db1 is not db2
-    
+
     # Test both instances work
     app = FastAPI()
     engine = create_async_engine("sqlite+aiosqlite://")
-    
+
     middleware1 = SQLAlchemyMiddleware1(app, custom_engine=engine)
     middleware2 = SQLAlchemyMiddleware2(app, custom_engine=engine)
-    
-    assert middleware1 is not middleware2
+
+    assert middleware1 is not middleware2