fastapi-transactional 0.1.0__py3-none-any.whl

fastapi_transactional/__init__.py

@@ -0,0 +1,53 @@
+"""fastapi-transactional — transactional session management for SQLAlchemy.
+
+Public API:
+    Configuration
+        configure, reset
+
+    Sync
+        session_manager, with_transaction
+        get_current_session, set_current_session, clear_current_session
+        DatabaseRepository
+
+    Async
+        async_session_manager, with_async_transaction
+        get_current_async_session, set_current_async_session, clear_current_async_session
+        AsyncDatabaseRepository
+"""
+
+from ._config import configure, reset
+from .async_session_context import (
+    clear_current_async_session,
+    get_current_async_session,
+    set_current_async_session,
+)
+from .async_session_manager import async_session_manager, with_async_transaction
+from .repository import AsyncDatabaseRepository, DatabaseRepository
+from .session_context import (
+    clear_current_session,
+    get_current_session,
+    set_current_session,
+)
+from .session_manager import session_manager, with_transaction
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "configure",
+    "reset",
+    # Sync
+    "session_manager",
+    "with_transaction",
+    "get_current_session",
+    "set_current_session",
+    "clear_current_session",
+    "DatabaseRepository",
+    # Async
+    "async_session_manager",
+    "with_async_transaction",
+    "get_current_async_session",
+    "set_current_async_session",
+    "clear_current_async_session",
+    "AsyncDatabaseRepository",
+]

fastapi_transactional/_config.py

@@ -0,0 +1,76 @@
+"""Module-level configuration for session factories.
+
+Users call ``configure()`` once at application startup to wire in the
+SQLAlchemy session factory the rest of the library should use. The library
+keeps no global state beyond what is set here, and configuration can be
+reset (useful in tests).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+    from sqlalchemy.orm import Session, sessionmaker
+
+
+class _Config:
+    __slots__ = ("session_factory", "async_session_factory")
+
+    def __init__(self) -> None:
+        self.session_factory: sessionmaker[Session] | None = None
+        self.async_session_factory: async_sessionmaker[AsyncSession] | None = None
+
+
+_config = _Config()
+
+
+def configure(
+    *,
+    session_factory: sessionmaker[Session] | None = None,
+    async_session_factory: async_sessionmaker[AsyncSession] | None = None,
+) -> None:
+    """Register the session factory (sync, async, or both).
+
+    Call this once at startup, after creating your SQLAlchemy engine(s).
+
+    Example:
+        from sqlalchemy import create_engine
+        from sqlalchemy.orm import sessionmaker
+        from fastapi_transactional import configure
+
+        engine = create_engine("postgresql://...")
+        SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False)
+        configure(session_factory=SessionLocal)
+    """
+    if session_factory is None and async_session_factory is None:
+        raise ValueError("configure() requires at least one of session_factory or async_session_factory.")
+    if session_factory is not None:
+        _config.session_factory = session_factory
+    if async_session_factory is not None:
+        _config.async_session_factory = async_session_factory
+
+
+def reset() -> None:
+    """Clear the registered session factories. Mostly useful in tests."""
+    _config.session_factory = None
+    _config.async_session_factory = None
+
+
+def _get_session_factory() -> sessionmaker[Session]:
+    if _config.session_factory is None:
+        raise RuntimeError(
+            "fastapi_transactional is not configured for sync sessions. "
+            "Call configure(session_factory=...) at application startup."
+        )
+    return _config.session_factory
+
+
+def _get_async_session_factory() -> async_sessionmaker[AsyncSession]:
+    if _config.async_session_factory is None:
+        raise RuntimeError(
+            "fastapi_transactional is not configured for async sessions. "
+            "Call configure(async_session_factory=...) at application startup."
+        )
+    return _config.async_session_factory

fastapi_transactional/async_session_context.py

@@ -0,0 +1,28 @@
+"""Per-context storage for the active async SQLAlchemy session.
+
+Separate ``ContextVar`` from the sync one so that an application using both
+sync and async sessions never accidentally cross-wires them.
+"""
+
+from __future__ import annotations
+
+from contextvars import ContextVar
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+_current_async_session: ContextVar[AsyncSession | None] = ContextVar("current_async_session", default=None)
+
+
+def get_current_async_session() -> AsyncSession | None:
+    """Return the async session bound to the current context, or ``None``."""
+    return _current_async_session.get()
+
+
+def set_current_async_session(session: AsyncSession) -> None:
+    """Bind ``session`` to the current context."""
+    _current_async_session.set(session)
+
+
+def clear_current_async_session() -> None:
+    """Remove any async session bound to the current context."""
+    _current_async_session.set(None)

fastapi_transactional/async_session_manager.py

@@ -0,0 +1,77 @@
+"""Async transactional scope: ``async_session_manager`` + ``@with_async_transaction``."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Awaitable, Callable
+from contextlib import asynccontextmanager
+from functools import wraps
+from typing import Any, TypeVar
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from ._config import _get_async_session_factory
+from .async_session_context import (
+    clear_current_async_session,
+    get_current_async_session,
+    set_current_async_session,
+)
+from .repository import AsyncDatabaseRepository
+
+F = TypeVar("F", bound=Callable[..., Awaitable[Any]])
+
+
+@asynccontextmanager
+async def async_session_manager() -> AsyncIterator[AsyncSession]:
+    """Async counterpart to :func:`session_manager`.
+
+    Yields an :class:`AsyncSession`, commits on clean exit, rolls back on
+    exception, and clears the context on the way out. Nested calls reuse the
+    outer session.
+    """
+    existing_session = get_current_async_session()
+    if existing_session is not None:
+        yield existing_session
+        return
+
+    session_factory = _get_async_session_factory()
+    session: AsyncSession = session_factory()
+    try:
+        set_current_async_session(session)
+        yield session
+        await session.commit()
+    except Exception:
+        await session.rollback()
+        raise
+    finally:
+        clear_current_async_session()
+        await session.close()
+
+
+def _inject_async_session_into_instance(instance: Any, session: AsyncSession) -> None:
+    """Set ``session`` on every :class:`AsyncDatabaseRepository` attribute of ``instance``."""
+    for attr_name in dir(instance):
+        if attr_name.startswith("__"):
+            continue
+        try:
+            attr = getattr(instance, attr_name)
+        except AttributeError:
+            continue
+        if isinstance(attr, AsyncDatabaseRepository):
+            attr.set_session(session)
+
+
+def with_async_transaction(func: F) -> F:
+    """Async counterpart to :func:`with_transaction`.
+
+    Wrap a coroutine method so it runs inside :func:`async_session_manager`,
+    injecting the active session into every :class:`AsyncDatabaseRepository`
+    attribute of ``self`` before the method body runs.
+    """
+
+    @wraps(func)
+    async def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
+        async with async_session_manager() as session:
+            _inject_async_session_into_instance(self, session)
+            return await func(self, *args, **kwargs)
+
+    return wrapper  # type: ignore[return-value]

fastapi_transactional/repository.py

@@ -0,0 +1,33 @@
+"""Base classes for repositories that participate in a managed transaction.
+
+A repository inheriting from :class:`DatabaseRepository` (sync) or
+:class:`AsyncDatabaseRepository` (async) exposes a ``self.db`` session
+slot. When the repository instance is an attribute of an object whose
+method is decorated with ``@with_transaction`` / ``@with_async_transaction``,
+the active session is injected into ``self.db`` for the duration of the call.
+"""
+
+from __future__ import annotations
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
+
+
+class DatabaseRepository:
+    """Base class for sync repositories backed by a SQLAlchemy session."""
+
+    def __init__(self) -> None:
+        self.db: Session | None = None
+
+    def set_session(self, db: Session) -> None:
+        self.db = db
+
+
+class AsyncDatabaseRepository:
+    """Base class for async repositories backed by an AsyncSession."""
+
+    def __init__(self) -> None:
+        self.db: AsyncSession | None = None
+
+    def set_session(self, db: AsyncSession) -> None:
+        self.db = db

fastapi_transactional/session_context.py

@@ -0,0 +1,29 @@
+"""Per-context storage for the active sync SQLAlchemy session.
+
+Backed by ``ContextVar`` so each thread / asyncio task sees its own value,
+which makes the session implicitly shared across repositories that run
+inside the same transactional scope without having to pass it around.
+"""
+
+from __future__ import annotations
+
+from contextvars import ContextVar
+
+from sqlalchemy.orm import Session
+
+_current_session: ContextVar[Session | None] = ContextVar("current_session", default=None)
+
+
+def get_current_session() -> Session | None:
+    """Return the session bound to the current context, or ``None``."""
+    return _current_session.get()
+
+
+def set_current_session(session: Session) -> None:
+    """Bind ``session`` to the current context."""
+    _current_session.set(session)
+
+
+def clear_current_session() -> None:
+    """Remove any session bound to the current context."""
+    _current_session.set(None)

fastapi_transactional/session_manager.py

@@ -0,0 +1,83 @@
+"""Sync transactional scope: ``session_manager`` and ``@with_transaction``.
+
+Open a new SQLAlchemy session, bind it to the context, commit on clean exit,
+roll back on exception, and clear the context on the way out. Nested calls
+reuse the outer session instead of opening a new one, which is what enables
+composition between use cases.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from functools import wraps
+from typing import Any, TypeVar
+
+from sqlalchemy.orm import Session
+
+from ._config import _get_session_factory
+from .repository import DatabaseRepository
+from .session_context import (
+    clear_current_session,
+    get_current_session,
+    set_current_session,
+)
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+@contextmanager
+def session_manager() -> Iterator[Session]:
+    """Provide a transactional scope around a series of operations.
+
+    If a session is already bound to the current context (i.e. we are nested
+    inside another ``session_manager`` block), that session is yielded as-is
+    and the outer block stays responsible for commit / rollback / close.
+    """
+    existing_session = get_current_session()
+    if existing_session is not None:
+        yield existing_session
+        return
+
+    session_factory = _get_session_factory()
+    session: Session = session_factory()
+    try:
+        set_current_session(session)
+        yield session
+        session.commit()
+    except Exception:
+        session.rollback()
+        raise
+    finally:
+        clear_current_session()
+        session.close()
+
+
+def _inject_session_into_instance(instance: Any, session: Session) -> None:
+    """Set ``session`` on every :class:`DatabaseRepository` attribute of ``instance``."""
+    for attr_name in dir(instance):
+        if attr_name.startswith("__"):
+            continue
+        try:
+            attr = getattr(instance, attr_name)
+        except AttributeError:
+            continue
+        if isinstance(attr, DatabaseRepository):
+            attr.set_session(session)
+
+
+def with_transaction(func: F) -> F:
+    """Wrap a method so it runs inside :func:`session_manager`.
+
+    Before the wrapped method runs, every :class:`DatabaseRepository`
+    attribute on ``self`` has its session set to the active one, so
+    repositories can do ``self.db.add(...)`` etc. without any plumbing.
+    """
+
+    @wraps(func)
+    def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
+        with session_manager() as session:
+            _inject_session_into_instance(self, session)
+            return func(self, *args, **kwargs)
+
+    return wrapper  # type: ignore[return-value]

fastapi_transactional-0.1.0.dist-info/METADATA

@@ -0,0 +1,256 @@
+Metadata-Version: 2.4
+Name: fastapi-transactional
+Version: 0.1.0
+Summary: Transactional session management for SQLAlchemy use cases (sync + async).
+Project-URL: Homepage, https://github.com/oviladrosa/fastapi-transactional
+Project-URL: Repository, https://github.com/oviladrosa/fastapi-transactional
+Project-URL: Issues, https://github.com/oviladrosa/fastapi-transactional/issues
+Project-URL: Changelog, https://github.com/oviladrosa/fastapi-transactional/blob/main/CHANGELOG.md
+Author-email: Oriol Viladrosa <oviladrosa@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 uri_vg
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: async,context-manager,decorator,fastapi,hexagonal-architecture,sqlalchemy,transactions
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: sqlalchemy>=2.0
+Provides-Extra: dev
+Requires-Dist: aiosqlite>=0.19; extra == 'dev'
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: greenlet>=3; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pre-commit>=3.7; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=4; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Requires-Dist: twine>=5; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: aiosqlite>=0.19; extra == 'test'
+Requires-Dist: greenlet>=3; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
+Requires-Dist: pytest-cov>=4; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# fastapi-transactional
+
+[![PyPI version](https://img.shields.io/pypi/v/fastapi-transactional.svg)](https://pypi.org/project/fastapi-transactional/)
+[![Python versions](https://img.shields.io/pypi/pyversions/fastapi-transactional.svg)](https://pypi.org/project/fastapi-transactional/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![CI](https://github.com/oviladrosa/fastapi-transactional/actions/workflows/ci.yml/badge.svg)](https://github.com/oviladrosa/fastapi-transactional/actions/workflows/ci.yml)
+
+Transactional session management for SQLAlchemy use cases — sync and async. Built for FastAPI and other apps that follow hexagonal / clean architecture, where a single use case orchestrates multiple repositories and they all need to share one transaction.
+
+```python
+@with_transaction
+def execute(self, policy_id: str) -> None:
+    policy = self.policy_repo.find_by_id(policy_id)
+    policy.status = "ACTIVE"
+    self.policy_repo.save(policy)
+    self.notification_repo.save(Notification(policy_id=policy_id))
+    # Commit on success. Rollback on any exception. Both repos share the same session.
+```
+
+## Why
+
+In a hexagonal architecture, a use case typically depends on multiple repositories:
+
+```python
+class ActivatePolicyUseCase:
+    def __init__(self):
+        self.policy_repo = PolicyRepository()
+        self.notification_repo = NotificationRepository()
+```
+
+If each repository opens its own session, you lose transactional guarantees — a failure in `notification_repo.save()` won't undo the change in `policy_repo.save()`. The usual fix is to pass a session around explicitly, which leaks infrastructure into the domain layer.
+
+`fastapi-transactional` solves this with a `ContextVar`-based session and a one-line decorator. Every repository inheriting from `DatabaseRepository` automatically receives the active session before the use case runs.
+
+## Install
+
+```bash
+pip install fastapi-transactional
+```
+
+Requires Python 3.10+ and SQLAlchemy 2.0+.
+
+## Quickstart — sync
+
+```python
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from fastapi_transactional import (
+    DatabaseRepository, configure, with_transaction,
+)
+
+# 1. Configure once at startup.
+engine = create_engine("postgresql+psycopg://user:pass@host/db")
+SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False)
+configure(session_factory=SessionLocal)
+
+
+# 2. Inherit from DatabaseRepository — `self.db` is injected automatically.
+class PolicyRepository(DatabaseRepository):
+    def find_by_id(self, policy_id):
+        return self.db.get(Policy, policy_id)
+
+    def save(self, policy):
+        self.db.add(policy)
+
+
+# 3. Decorate the use case method.
+class ActivatePolicyUseCase:
+    def __init__(self):
+        self.policy_repo = PolicyRepository()
+
+    @with_transaction
+    def execute(self, policy_id: str) -> None:
+        policy = self.policy_repo.find_by_id(policy_id)
+        policy.status = "ACTIVE"
+        self.policy_repo.save(policy)
+```
+
+## Quickstart — async
+
+```python
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from fastapi_transactional import (
+    AsyncDatabaseRepository, configure, with_async_transaction,
+)
+
+engine = create_async_engine("postgresql+asyncpg://user:pass@host/db")
+AsyncSessionLocal = async_sessionmaker(bind=engine, expire_on_commit=False)
+configure(async_session_factory=AsyncSessionLocal)
+
+
+class PolicyRepository(AsyncDatabaseRepository):
+    async def find_by_id(self, policy_id):
+        return await self.db.get(Policy, policy_id)
+
+    async def save(self, policy):
+        self.db.add(policy)
+
+
+class ActivatePolicyUseCase:
+    def __init__(self):
+        self.policy_repo = PolicyRepository()
+
+    @with_async_transaction
+    async def execute(self, policy_id: str) -> None:
+        policy = await self.policy_repo.find_by_id(policy_id)
+        policy.status = "ACTIVE"
+        await self.policy_repo.save(policy)
+```
+
+You can configure both sync and async factories at the same time — they live in separate `ContextVar`s and don't interfere.
+
+## How it works
+
+1. The decorator opens a `session_manager()` (sync) or `async_session_manager()` (async) context.
+2. The manager creates a session from the factory you registered with `configure(...)` and stores it in a `ContextVar`.
+3. The decorator scans `self` for attributes that are `DatabaseRepository` / `AsyncDatabaseRepository` instances and sets their `.db` to the active session.
+4. Your method runs. On clean exit the session commits; on any exception it rolls back.
+5. The session is always closed and removed from the `ContextVar`.
+
+`ContextVar` is thread-safe and asyncio-safe — each request handler gets its own slot, so concurrent requests never see each other's sessions.
+
+## Nested use cases
+
+A use case can call another use case without worrying about double transactions:
+
+```python
+class Outer:
+    def __init__(self):
+        self.inner = Inner()
+
+    @with_transaction
+    def execute(self):
+        self.inner.execute()      # Reuses the outer session.
+        self.repo.save(thing)     # Same transaction.
+        # Single commit when execute() returns.
+```
+
+When `session_manager()` sees an existing session bound to the context, it yields that session instead of opening a new one — so the outermost call owns the transaction lifecycle.
+
+## Advanced — accessing the session directly
+
+For code that isn't a repository (e.g. a service that needs to run a raw query inside the active transaction):
+
+```python
+from fastapi_transactional import get_current_session
+
+def some_service():
+    session = get_current_session()
+    if session is None:
+        raise RuntimeError("Must be called inside a transactional scope")
+    session.execute(...)
+```
+
+The async equivalents are `get_current_async_session`, `set_current_async_session`, `clear_current_async_session`.
+
+You can also use the context manager directly without the decorator:
+
+```python
+with session_manager() as session:
+    session.execute(...)
+# Commit happens here. Rollback on exception.
+```
+
+## API reference
+
+| Symbol | Purpose |
+|---|---|
+| `configure(session_factory=..., async_session_factory=...)` | Register session factories (call once at startup). |
+| `reset()` | Clear the registered factories (useful in tests). |
+| `session_manager()` / `async_session_manager()` | Context manager that opens a transactional scope. |
+| `with_transaction` / `with_async_transaction` | Decorator wrapping a method in a transactional scope and injecting sessions into repositories. |
+| `DatabaseRepository` / `AsyncDatabaseRepository` | Base class — gives the repo a `self.db` slot. |
+| `get_current_session` / `set_current_session` / `clear_current_session` | Direct access to the sync ContextVar. |
+| `get_current_async_session` / `set_current_async_session` / `clear_current_async_session` | Direct access to the async ContextVar. |
+
+## Tests
+
+```bash
+pip install -e ".[test]"
+pytest --cov=fastapi_transactional
+```
+
+## Contributing
+
+Issues and pull requests welcome. See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

fastapi_transactional-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+fastapi_transactional/__init__.py,sha256=3O0-4lCF_QPa-kg1naq9k4Ynct3fzoN-1KUl46VYNDo,1428
+fastapi_transactional/_config.py,sha256=YQcG2b8CqptWzm3uodxbWdx3I5SGg33u7TnOAc1OlSc,2653
+fastapi_transactional/async_session_context.py,sha256=FJlJ7jPkMAK_l3WyJYCUNn64HGhdhIdT2fvGIdSybbA,914
+fastapi_transactional/async_session_manager.py,sha256=z58rW-uUdi5Uqsc87Rr2nguFLG8Qzg7mVVeAhFeM_3g,2544
+fastapi_transactional/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_transactional/repository.py,sha256=pnjaFjslPv9tH_YQ6P30gKw3sK2UKc-y_ndVk5gUizE,1066
+fastapi_transactional/session_context.py,sha256=aVlBULylyROO6BLoBk9PP6iwor0NRc2TtaqFKAruUfU,904
+fastapi_transactional/session_manager.py,sha256=9ne5TmCXrzBfhYrpfd4o58gkzeG-sNOGCIwOCJsAwNQ,2666
+fastapi_transactional-0.1.0.dist-info/METADATA,sha256=z5woCpjhXRkaF3AD0nvxJwbdAeJgrY658xNku7MzE-8,10441
+fastapi_transactional-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+fastapi_transactional-0.1.0.dist-info/licenses/LICENSE,sha256=KQoUMac4dYeGcakqJzLVWfNcwm_sYN8KcAzv1uHvSfM,1063
+fastapi_transactional-0.1.0.dist-info/RECORD,,

fastapi_transactional-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fastapi_transactional-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 uri_vg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.