jararaca 0.3.11a3__tar.gz → 0.3.11a4__tar.gz

{jararaca-0.3.11a3 → jararaca-0.3.11a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jararaca
-Version: 0.3.11a3
+Version: 0.3.11a4
 Summary: A simple and fast API framework for Python
 Author: Lucas S
 Author-email: me@luscasleo.dev

{jararaca-0.3.11a3 → jararaca-0.3.11a4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jararaca"
-version = "0.3.11a3"
+version = "0.3.11a4"
 description = "A simple and fast API framework for Python"
 authors = ["Lucas S <me@luscasleo.dev>"]
 readme = "README.md"

{jararaca-0.3.11a3 → jararaca-0.3.11a4}/src/jararaca/__init__.py

@@ -73,7 +73,11 @@ if TYPE_CHECKING:
     from .persistence.interceptors.aiosqa_interceptor import (
         AIOSQAConfig,
         AIOSqlAlchemySessionInterceptor,
+        providing_new_session,
+        providing_session,
+        providing_transaction,
         use_session,
+        use_transaction,
     )
     from .persistence.utilities import (
         CriteriaBasedAttributeQueryInjector,
@@ -191,6 +195,10 @@ if TYPE_CHECKING:
         "Container",
         "WebSocketInterceptor",
         "use_session",
+        "use_transaction",
+        "providing_session",
+        "providing_transaction",
+        "providing_new_session",
         "Post",
         "Get",
         "Patch",
@@ -335,6 +343,26 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
         "persistence.interceptors.aiosqa_interceptor",
         None,
     ),
+    "use_transaction": (
+        __SPEC_PARENT__,
+        "persistence.interceptors.aiosqa_interceptor",
+        None,
+    ),
+    "providing_session": (
+        __SPEC_PARENT__,
+        "persistence.interceptors.aiosqa_interceptor",
+        None,
+    ),
+    "providing_new_session": (
+        __SPEC_PARENT__,
+        "persistence.interceptors.aiosqa_interceptor",
+        None,
+    ),
+    "providing_transaction": (
+        __SPEC_PARENT__,
+        "persistence.interceptors.aiosqa_interceptor",
+        None,
+    ),
     "Post": (__SPEC_PARENT__, "presentation.decorators", None),
     "Get": (__SPEC_PARENT__, "presentation.decorators", None),
     "Patch": (__SPEC_PARENT__, "presentation.decorators", None),

{jararaca-0.3.11a3 → jararaca-0.3.11a4}/src/jararaca/persistence/base.py

@@ -1,6 +1,7 @@
 from typing import Any, Self, Type, TypeVar
 
 from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncAttrs
 from sqlalchemy.orm import DeclarativeBase
 
 IDENTIFIABLE_SCHEMA_T = TypeVar("IDENTIFIABLE_SCHEMA_T")
@@ -20,7 +21,7 @@ def recursive_get_dict(obj: Any) -> Any:
         return obj
 
 
-class BaseEntity(DeclarativeBase):
+class BaseEntity(AsyncAttrs, DeclarativeBase):
 
     @classmethod
     def from_basemodel(cls, mutation: T_BASEMODEL) -> "Self":

jararaca-0.3.11a4/src/jararaca/persistence/interceptors/aiosqa_interceptor.py

@@ -0,0 +1,137 @@
+from contextlib import asynccontextmanager, contextmanager, suppress
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Any, AsyncGenerator, Generator
+
+from sqlalchemy.ext.asyncio import (
+    AsyncSession,
+    AsyncSessionTransaction,
+    async_sessionmaker,
+    create_async_engine,
+)
+from sqlalchemy.ext.asyncio.engine import AsyncEngine
+
+from jararaca.microservice import AppContext, AppInterceptor
+
+ctx_default_connection_name: ContextVar[str] = ContextVar("ctx_default_connection_name")
+
+
+def ensure_name(name: str | None) -> str:
+    if name is None:
+        return ctx_default_connection_name.get()
+    return name
+
+
+@dataclass
+class PersistenceCtx:
+    session: AsyncSession
+    tx: AsyncSessionTransaction
+
+
+ctx_session_map = ContextVar[dict[str, PersistenceCtx]]("ctx_session_map", default={})
+
+
+@contextmanager
+def providing_session(
+    session: AsyncSession,
+    tx: AsyncSessionTransaction,
+    connection_name: str | None = None,
+) -> Generator[None, Any, None]:
+
+    connection_name = ensure_name(connection_name)
+    current_map = ctx_session_map.get({})
+
+    token = ctx_session_map.set(
+        {**current_map, connection_name: PersistenceCtx(session, tx)}
+    )
+
+    try:
+        yield
+    finally:
+        with suppress(ValueError):
+            ctx_session_map.reset(token)
+
+
+@asynccontextmanager
+async def providing_new_session(
+    connection_name: str | None = None,
+) -> AsyncGenerator[AsyncSession, None]:
+
+    current_session = use_session(connection_name)
+
+    async with AsyncSession(
+        current_session.bind,
+    ) as new_session, new_session.begin() as new_tx:
+        with providing_session(new_session, new_tx, connection_name):
+            yield new_session
+
+
+def use_session(connection_name: str | None = None) -> AsyncSession:
+    connection_name = ensure_name(connection_name)
+    current_map = ctx_session_map.get({})
+    if connection_name not in current_map:
+        raise ValueError(f"Session not found for connection {connection_name}")
+
+    return current_map[connection_name].session
+
+
+@contextmanager
+def providing_transaction(
+    tx: AsyncSessionTransaction,
+    connection_name: str | None = None,
+) -> Generator[None, Any, None]:
+    connection_name = ensure_name(connection_name)
+
+    current_map = ctx_session_map.get({})
+
+    if connection_name not in current_map:
+        raise ValueError(f"No session found for connection {connection_name}")
+
+    with providing_session(current_map[connection_name].session, tx, connection_name):
+        yield
+
+
+def use_transaction(connection_name: str | None = None) -> AsyncSessionTransaction:
+    current_map = ctx_session_map.get({})
+    if connection_name not in current_map:
+        raise ValueError(f"Transaction not found for connection {connection_name}")
+
+    return current_map[connection_name].tx
+
+
+class AIOSQAConfig:
+    url: str | AsyncEngine
+    connection_name: str
+
+    def __init__(self, url: str | AsyncEngine, connection_name: str = "default"):
+        self.url = url
+        self.connection_name = connection_name
+
+
+class AIOSqlAlchemySessionInterceptor(AppInterceptor):
+
+    def __init__(self, config: AIOSQAConfig):
+        self.config = config
+        self.engine = (
+            create_async_engine(self.config.url)
+            if isinstance(self.config.url, str)
+            else self.config.url
+        )
+
+        self.sessionmaker = async_sessionmaker(self.engine)
+
+    @asynccontextmanager
+    async def intercept(self, app_context: AppContext) -> AsyncGenerator[None, None]:
+
+        async with self.sessionmaker() as session, session.begin() as tx:
+            token = ctx_default_connection_name.set(self.config.connection_name)
+            with providing_session(session, tx, self.config.connection_name):
+                try:
+                    yield
+                    if tx.is_active:
+                        await tx.commit()
+                except Exception as e:
+                    await tx.rollback()
+                    raise e
+                finally:
+                    ctx_default_connection_name.reset(token)

jararaca-0.3.11a3/src/jararaca/persistence/interceptors/aiosqa_interceptor.py

@@ -1,64 +0,0 @@
-from contextlib import asynccontextmanager, contextmanager, suppress
-from contextvars import ContextVar
-from dataclasses import dataclass
-from typing import Any, AsyncGenerator, Generator
-
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy.ext.asyncio.engine import AsyncEngine
-
-from jararaca.microservice import AppContext, AppInterceptor
-
-ctx_session_map = ContextVar[dict[str, AsyncSession]]("ctx_session_map", default={})
-
-
-@contextmanager
-def provide_session(
-    connection_name: str, session: AsyncSession
-) -> Generator[None, Any, None]:
-    current_map = ctx_session_map.get({})
-
-    token = ctx_session_map.set({**current_map, connection_name: session})
-
-    try:
-        yield
-    finally:
-        with suppress(ValueError):
-            ctx_session_map.reset(token)
-
-
-def use_session(connection_name: str = "default") -> AsyncSession:
-    current_map = ctx_session_map.get({})
-    if connection_name not in current_map:
-        raise ValueError(f"Session not found for connection {connection_name}")
-
-    return current_map[connection_name]
-
-
-@dataclass
-class AIOSQAConfig:
-    connection_name: str
-    url: str | AsyncEngine
-
-
-class AIOSqlAlchemySessionInterceptor(AppInterceptor):
-
-    def __init__(self, config: AIOSQAConfig):
-        self.config = config
-        self.engine = (
-            create_async_engine(self.config.url)
-            if isinstance(self.config.url, str)
-            else self.config.url
-        )
-
-        self.sessionmaker = async_sessionmaker(self.engine)
-
-    @asynccontextmanager
-    async def intercept(self, app_context: AppContext) -> AsyncGenerator[None, None]:
-        async with self.sessionmaker() as session:
-            with provide_session(self.config.connection_name, session):
-                try:
-                    yield
-                    await session.commit()
-                except Exception as e:
-                    await session.rollback()
-                    raise e