sqla-fancy-core 1.1.1__tar.gz → 1.1.2__tar.gz

{sqla_fancy_core-1.1.1 → sqla_fancy_core-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqla-fancy-core
-Version: 1.1.1
+Version: 1.1.2
 Summary: SQLAlchemy core, but fancier
 Project-URL: Homepage, https://github.com/sayanarijit/sqla-fancy-core
 Author-email: Arijit Basu <sayanarijit@gmail.com>
@@ -242,27 +242,24 @@ users = sa.Table(
 )
 metadata.create_all(engine)
 
-# 1) Ensure a connection is available (no implicit transaction)
 @connect
 def get_user_count(conn=Inject(engine)):
     return conn.execute(sa.select(sa.func.count()).select_from(users)).scalar_one()
 
 assert get_user_count() == 0
 
-# 2) Wrap in a transaction automatically
 @transact
 def create_user(name: str, conn=Inject(engine)):
     conn.execute(sa.insert(users).values(name=name))
 
+# Without an explicit transaction
 create_user("alice")
 assert get_user_count() == 1
 
-# 3) Reuse an explicit connection or transaction
+# With an explicit transaction
 with engine.begin() as txn:
     create_user("bob", conn=txn)
     assert get_user_count(conn=txn) == 2
-
-assert get_user_count() == 2
 ```
 
 ### Async examples
@@ -293,10 +290,12 @@ async def get_user_count(conn=Inject(engine)):
 async def create_user(name: str, conn=Inject(engine)):
     await conn.execute(sa.insert(users).values(name=name))
 
+# Without an explicit transaction
 assert await get_user_count() == 0
 await create_user("carol")
 assert await get_user_count() == 1
 
+# With an explicit transaction
 async with engine.connect() as conn:
     await create_user("dave", conn=conn)
     assert await get_user_count(conn=conn) == 2

{sqla_fancy_core-1.1.1 → sqla_fancy_core-1.1.2}/README.md

@@ -190,27 +190,24 @@ users = sa.Table(
 )
 metadata.create_all(engine)
 
-# 1) Ensure a connection is available (no implicit transaction)
 @connect
 def get_user_count(conn=Inject(engine)):
     return conn.execute(sa.select(sa.func.count()).select_from(users)).scalar_one()
 
 assert get_user_count() == 0
 
-# 2) Wrap in a transaction automatically
 @transact
 def create_user(name: str, conn=Inject(engine)):
     conn.execute(sa.insert(users).values(name=name))
 
+# Without an explicit transaction
 create_user("alice")
 assert get_user_count() == 1
 
-# 3) Reuse an explicit connection or transaction
+# With an explicit transaction
 with engine.begin() as txn:
     create_user("bob", conn=txn)
     assert get_user_count(conn=txn) == 2
-
-assert get_user_count() == 2
 ```
 
 ### Async examples
@@ -241,10 +238,12 @@ async def get_user_count(conn=Inject(engine)):
 async def create_user(name: str, conn=Inject(engine)):
     await conn.execute(sa.insert(users).values(name=name))
 
+# Without an explicit transaction
 assert await get_user_count() == 0
 await create_user("carol")
 assert await get_user_count() == 1
 
+# With an explicit transaction
 async with engine.connect() as conn:
     await create_user("dave", conn=conn)
     assert await get_user_count(conn=conn) == 2

{sqla_fancy_core-1.1.1 → sqla_fancy_core-1.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = 'sqla-fancy-core'
-version = '1.1.1'
+version = '1.1.2'
 description = 'SQLAlchemy core, but fancier'
 readme = 'README.md'
 requires-python = ">=3.7"

{sqla_fancy_core-1.1.1 → sqla_fancy_core-1.1.2}/sqla_fancy_core/decorators.py

@@ -7,7 +7,9 @@ from typing import Union, overload
 import sqlalchemy as sa
 from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine
 
-EngineType = Union[sa.Engine, AsyncEngine]
+from sqla_fancy_core.wrappers import AsyncFancyEngineWrapper, FancyEngineWrapper
+
+EngineType = Union[sa.Engine, AsyncEngine, FancyEngineWrapper, AsyncFancyEngineWrapper]
 
 
 class _Injectable:
@@ -16,9 +18,9 @@ class _Injectable:
 
 
 @overload
-def Inject(engine: sa.Engine) -> sa.Connection: ...
+def Inject(engine: Union[sa.Engine, FancyEngineWrapper]) -> sa.Connection: ...
 @overload
-def Inject(engine: AsyncEngine) -> AsyncConnection: ...
+def Inject(engine: Union[AsyncEngine, AsyncFancyEngineWrapper]) -> AsyncConnection: ...
 def Inject(engine: EngineType):  # type: ignore
     """A marker class for dependency injection."""
     return _Injectable(engine)
@@ -44,7 +46,6 @@ def transact(func):
             create_user(name="existing", conn=conn)
     """
 
-    # Find the parameter with value Inject
     sig = inspect.signature(func)
     inject_param_name = None
     for name, param in sig.parameters.items():
@@ -56,8 +57,21 @@ def transact(func):
     if inject_param_name is None:
         return func  # No injection needed
 
-    engine = sig.parameters[inject_param_name].default.engine
-    is_async = isinstance(engine, AsyncEngine)
+    engine_arg = sig.parameters[inject_param_name].default.engine
+    if isinstance(engine_arg, sa.Engine):
+        is_async = False
+        engine = engine_arg
+    elif isinstance(engine_arg, FancyEngineWrapper):
+        is_async = False
+        engine = engine_arg.engine
+    elif isinstance(engine_arg, AsyncEngine):
+        is_async = True
+        engine = engine_arg
+    elif isinstance(engine_arg, AsyncFancyEngineWrapper):
+        is_async = True
+        engine = engine_arg.engine
+    else:
+        raise TypeError("Unsupported engine type")
 
     if is_async:
 
@@ -70,8 +84,14 @@ def transact(func):
                 else:
                     async with conn.begin():
                         return await func(*args, **kwargs)
+            elif isinstance(conn, sa.Connection):
+                if conn.in_transaction():
+                    return await func(*args, **kwargs)
+                else:
+                    with conn.begin():
+                        return await func(*args, **kwargs)
             else:
-                async with engine.begin() as conn:
+                async with engine.begin() as conn:  # type: ignore
                     kwargs[inject_param_name] = conn
                     return await func(*args, **kwargs)
 
@@ -88,8 +108,10 @@ def transact(func):
                 else:
                     with conn.begin():
                         return func(*args, **kwargs)
+            elif isinstance(conn, AsyncConnection):
+                raise TypeError("AsyncConnection cannot be used in sync function")
             else:
-                with engine.begin() as conn:
+                with engine.begin() as conn:  # type: ignore
                     kwargs[inject_param_name] = conn
                     return func(*args, **kwargs)
 
@@ -116,7 +138,6 @@ def connect(func):
             count = get_user_count(conn)
     """
 
-    # Find the parameter with value Inject
     sig = inspect.signature(func)
     inject_param_name = None
     for name, param in sig.parameters.items():
@@ -128,18 +149,31 @@ def connect(func):
     if inject_param_name is None:
         return func  # No injection needed
 
-    engine = sig.parameters[inject_param_name].default.engine
-    is_async = isinstance(engine, AsyncEngine)
+    engine_arg = sig.parameters[inject_param_name].default.engine
+    if isinstance(engine_arg, sa.Engine):
+        is_async = False
+        engine = engine_arg
+    elif isinstance(engine_arg, FancyEngineWrapper):
+        is_async = False
+        engine = engine_arg.engine
+    elif isinstance(engine_arg, AsyncEngine):
+        is_async = True
+        engine = engine_arg
+    elif isinstance(engine_arg, AsyncFancyEngineWrapper):
+        is_async = True
+        engine = engine_arg.engine
+    else:
+        raise TypeError("Unsupported engine type")
 
     if is_async:
 
         @functools.wraps(func)
         async def async_wrapper(*args, **kwargs):
             conn = kwargs.get(inject_param_name)
-            if isinstance(conn, AsyncConnection):
+            if isinstance(conn, (AsyncConnection, sa.Connection)):
                 return await func(*args, **kwargs)
             else:
-                async with engine.connect() as conn:
+                async with engine.connect() as conn:  # type: ignore
                     kwargs[inject_param_name] = conn
                     return await func(*args, **kwargs)
 
@@ -152,8 +186,10 @@ def connect(func):
             conn = kwargs.get(inject_param_name)
             if isinstance(conn, sa.Connection):
                 return func(*args, **kwargs)
+            elif isinstance(conn, AsyncConnection):
+                raise TypeError("AsyncConnection cannot be used in sync function")
             else:
-                with engine.connect() as conn:
+                with engine.connect() as conn:  # type: ignore
                     kwargs[inject_param_name] = conn
                     return func(*args, **kwargs)
 

sqla_fancy_core-1.1.2/tests/test_decorators.py

@@ -0,0 +1,448 @@
+"""Tests for decorator functionality with fancy wrappers and edge cases."""
+
+import pytest
+import pytest_asyncio
+import sqlalchemy as sa
+from sqlalchemy.ext.asyncio import AsyncConnection, create_async_engine
+
+from sqla_fancy_core.decorators import Inject, connect, transact
+from sqla_fancy_core.wrappers import fancy
+
+# Define a simple table for testing
+metadata = sa.MetaData()
+users = sa.Table(
+    "users",
+    metadata,
+    sa.Column("id", sa.Integer, primary_key=True, autoincrement=True),
+    sa.Column("name", sa.String),
+)
+
+
+@pytest.fixture
+def sync_engine():
+    """Provides a synchronous in-memory SQLite engine."""
+    engine = sa.create_engine(
+        "sqlite:///:memory:",
+        connect_args={"check_same_thread": False},
+        poolclass=sa.pool.StaticPool,
+    )
+    metadata.create_all(engine)
+    yield engine
+    metadata.drop_all(engine)
+    engine.dispose()
+
+
+@pytest_asyncio.fixture
+async def async_engine():
+    """Provides an asynchronous in-memory SQLite engine."""
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    async with engine.begin() as conn:
+        await conn.run_sync(metadata.create_all)
+    yield engine
+    async with engine.begin() as conn:
+        await conn.run_sync(metadata.drop_all)
+    await engine.dispose()
+
+
+# Tests for @connect with FancyEngineWrapper
+def test_connect_with_fancy_wrapper(sync_engine):
+    """Test @connect decorator with FancyEngineWrapper."""
+    fancy_engine = fancy(sync_engine)
+
+    @connect
+    def get_user_count(conn=Inject(fancy_engine)):
+        return conn.execute(sa.select(sa.func.count()).select_from(users)).scalar_one()
+
+    # Should work without explicit connection
+    assert get_user_count() == 0
+
+    # Should work with explicit connection
+    with sync_engine.connect() as conn:
+        assert get_user_count(conn=conn) == 0
+
+
+def test_connect_with_fancy_wrapper_and_data(sync_engine):
+    """Test @connect decorator with FancyEngineWrapper after inserting data."""
+    fancy_engine = fancy(sync_engine)
+
+    @connect
+    def get_user_count(conn=Inject(fancy_engine)):
+        return conn.execute(sa.select(sa.func.count()).select_from(users)).scalar_one()
+
+    # Insert some data
+    with sync_engine.begin() as conn:
+        conn.execute(sa.insert(users).values(name="Alice"))
+        conn.execute(sa.insert(users).values(name="Bob"))
+
+    assert get_user_count() == 2
+
+
+# Tests for @transact with FancyEngineWrapper
+def test_transact_with_fancy_wrapper(sync_engine):
+    """Test @transact decorator with FancyEngineWrapper."""
+    fancy_engine = fancy(sync_engine)
+
+    @transact
+    def create_user(name: str, conn=Inject(fancy_engine)):
+        conn.execute(sa.insert(users).values(name=name))
+
+    @connect
+    def get_user_count(conn=Inject(fancy_engine)):
+        return conn.execute(sa.select(sa.func.count()).select_from(users)).scalar_one()
+
+    # Create user without explicit transaction
+    create_user("Alice")
+    assert get_user_count() == 1
+
+    # Create user with explicit transaction
+    with sync_engine.begin() as conn:
+        create_user("Bob", conn=conn)
+
+    assert get_user_count() == 2
+
+
+def test_transact_with_fancy_wrapper_rollback(sync_engine):
+    """Test @transact decorator with FancyEngineWrapper and rollback."""
+    fancy_engine = fancy(sync_engine)
+
+    @transact
+    def create_user(name: str, conn=Inject(fancy_engine)):
+        conn.execute(sa.insert(users).values(name=name))
+
+    @connect
+    def get_user_count(conn=Inject(fancy_engine)):
+        return conn.execute(sa.select(sa.func.count()).select_from(users)).scalar_one()
+
+    # Test that rollback works
+    try:
+        with sync_engine.begin() as conn:
+            create_user("Alice", conn=conn)
+            raise ValueError("Test rollback")
+    except ValueError:
+        pass
+
+    # User should not be created due to rollback
+    assert get_user_count() == 0
+
+
+def test_transact_reuses_existing_transaction(sync_engine):
+    """Test that @transact reuses an existing transaction."""
+    fancy_engine = fancy(sync_engine)
+
+    call_count = {"begin": 0}
+
+    @transact
+    def create_user(name: str, conn=Inject(fancy_engine)):
+        conn.execute(sa.insert(users).values(name=name))
+
+    @connect
+    def get_user_count(conn=Inject(fancy_engine)):
+        return conn.execute(sa.select(sa.func.count()).select_from(users)).scalar_one()
+
+    # When called with a connection already in a transaction,
+    # it should not start a new transaction
+    with sync_engine.begin() as conn:
+        assert conn.in_transaction()
+        create_user("Alice", conn=conn)
+        create_user("Bob", conn=conn)
+
+    assert get_user_count() == 2
+
+
+def test_transact_starts_transaction_for_connection_without_transaction(sync_engine):
+    """Test that @transact starts a transaction if connection is not in one."""
+    fancy_engine = fancy(sync_engine)
+
+    @transact
+    def create_user(name: str, conn=Inject(fancy_engine)):
+        assert conn.in_transaction(), "Connection should be in a transaction"
+        conn.execute(sa.insert(users).values(name=name))
+
+    @connect
+    def get_user_count(conn=Inject(fancy_engine)):
+        return conn.execute(sa.select(sa.func.count()).select_from(users)).scalar_one()
+
+    # Pass a connection that is NOT in a transaction
+    with sync_engine.connect() as conn:
+        assert not conn.in_transaction()
+        create_user("Alice", conn=conn)
+
+    assert get_user_count() == 1
+
+
+# Tests for async @connect with AsyncFancyEngineWrapper
+@pytest.mark.asyncio
+async def test_async_connect_with_fancy_wrapper(async_engine):
+    """Test async @connect decorator with AsyncFancyEngineWrapper."""
+    fancy_engine = fancy(async_engine)
+
+    @connect
+    async def get_user_count(conn=Inject(fancy_engine)):
+        result = await conn.execute(sa.select(sa.func.count()).select_from(users))
+        return result.scalar_one()
+
+    # Should work without explicit connection
+    assert await get_user_count() == 0
+
+    # Should work with explicit connection
+    async with async_engine.connect() as conn:
+        assert await get_user_count(conn=conn) == 0
+
+
+@pytest.mark.asyncio
+async def test_async_connect_with_fancy_wrapper_and_data(async_engine):
+    """Test async @connect decorator with AsyncFancyEngineWrapper after inserting data."""
+    fancy_engine = fancy(async_engine)
+
+    @connect
+    async def get_user_count(conn=Inject(fancy_engine)):
+        result = await conn.execute(sa.select(sa.func.count()).select_from(users))
+        return result.scalar_one()
+
+    # Insert some data
+    async with async_engine.begin() as conn:
+        await conn.execute(sa.insert(users).values(name="Alice"))
+        await conn.execute(sa.insert(users).values(name="Bob"))
+
+    assert await get_user_count() == 2
+
+
+# Tests for async @transact with AsyncFancyEngineWrapper
+@pytest.mark.asyncio
+async def test_async_transact_with_fancy_wrapper(async_engine):
+    """Test async @transact decorator with AsyncFancyEngineWrapper."""
+    fancy_engine = fancy(async_engine)
+
+    @transact
+    async def create_user(name: str, conn=Inject(fancy_engine)):
+        await conn.execute(sa.insert(users).values(name=name))
+
+    @connect
+    async def get_user_count(conn=Inject(fancy_engine)):
+        result = await conn.execute(sa.select(sa.func.count()).select_from(users))
+        return result.scalar_one()
+
+    # Create user without explicit transaction
+    await create_user("Alice")
+    assert await get_user_count() == 1
+
+    # Create user with explicit transaction
+    async with async_engine.begin() as conn:
+        await create_user("Bob", conn=conn)
+
+    assert await get_user_count() == 2
+
+
+@pytest.mark.asyncio
+async def test_async_transact_with_fancy_wrapper_rollback(async_engine):
+    """Test async @transact decorator with AsyncFancyEngineWrapper and rollback."""
+    fancy_engine = fancy(async_engine)
+
+    @transact
+    async def create_user(name: str, conn=Inject(fancy_engine)):
+        await conn.execute(sa.insert(users).values(name=name))
+
+    @connect
+    async def get_user_count(conn=Inject(fancy_engine)):
+        result = await conn.execute(sa.select(sa.func.count()).select_from(users))
+        return result.scalar_one()
+
+    # Test that rollback works
+    try:
+        async with async_engine.begin() as conn:
+            await create_user("Alice", conn=conn)
+            raise ValueError("Test rollback")
+    except ValueError:
+        pass
+
+    # User should not be created due to rollback
+    assert await get_user_count() == 0
+
+
+@pytest.mark.asyncio
+async def test_async_transact_reuses_existing_transaction(async_engine):
+    """Test that async @transact reuses an existing transaction."""
+    fancy_engine = fancy(async_engine)
+
+    @transact
+    async def create_user(name: str, conn=Inject(fancy_engine)):
+        await conn.execute(sa.insert(users).values(name=name))
+
+    @connect
+    async def get_user_count(conn=Inject(fancy_engine)):
+        result = await conn.execute(sa.select(sa.func.count()).select_from(users))
+        return result.scalar_one()
+
+    # When called with a connection already in a transaction,
+    # it should not start a new transaction
+    async with async_engine.begin() as conn:
+        assert conn.in_transaction()
+        await create_user("Alice", conn=conn)
+        await create_user("Bob", conn=conn)
+
+    assert await get_user_count() == 2
+
+
+@pytest.mark.asyncio
+async def test_async_transact_starts_transaction_for_connection_without_transaction(
+    async_engine,
+):
+    """Test that async @transact starts a transaction if connection is not in one."""
+    fancy_engine = fancy(async_engine)
+
+    @transact
+    async def create_user(name: str, conn=Inject(fancy_engine)):
+        assert conn.in_transaction(), "Connection should be in a transaction"
+        await conn.execute(sa.insert(users).values(name=name))
+
+    @connect
+    async def get_user_count(conn=Inject(fancy_engine)):
+        result = await conn.execute(sa.select(sa.func.count()).select_from(users))
+        return result.scalar_one()
+
+    # Pass a connection that is NOT in a transaction
+    async with async_engine.connect() as conn:
+        assert not conn.in_transaction()
+        await create_user("Alice", conn=conn)
+
+    assert await get_user_count() == 1
+
+
+# Error handling tests
+@pytest.mark.asyncio
+async def test_sync_decorator_rejects_async_connection(sync_engine, async_engine):
+    """Test that sync decorator properly rejects AsyncConnection."""
+    fancy_engine = fancy(sync_engine)
+
+    @connect
+    def get_user_count(conn=Inject(fancy_engine)):
+        return conn.execute(sa.select(sa.func.count()).select_from(users)).scalar_one()
+
+    # Try to pass an actual AsyncConnection to a sync function
+    async with async_engine.connect() as async_conn:
+        with pytest.raises(TypeError, match="AsyncConnection cannot be used in sync function"):
+            get_user_count(conn=async_conn)
+
+
+@pytest.mark.asyncio
+async def test_sync_transact_rejects_async_connection(sync_engine, async_engine):
+    """Test that sync @transact properly rejects AsyncConnection."""
+    fancy_engine = fancy(sync_engine)
+
+    @transact
+    def create_user(name: str, conn=Inject(fancy_engine)):
+        conn.execute(sa.insert(users).values(name=name))
+
+    # Try to pass an actual AsyncConnection to a sync function
+    async with async_engine.connect() as async_conn:
+        with pytest.raises(TypeError, match="AsyncConnection cannot be used in sync function"):
+            create_user("Alice", conn=async_conn)
+
+
+def test_inject_with_unsupported_engine_type():
+    """Test that decorators reject unsupported engine types."""
+
+    class UnsupportedEngine:
+        pass
+
+    unsupported = UnsupportedEngine()
+
+    with pytest.raises(TypeError, match="Unsupported engine type"):
+
+        @connect
+        def test_func(conn=Inject(unsupported)):  # type: ignore
+            pass
+
+        test_func()
+
+
+def test_transact_with_unsupported_engine_type():
+    """Test that @transact rejects unsupported engine types."""
+
+    class UnsupportedEngine:
+        pass
+
+    unsupported = UnsupportedEngine()
+
+    with pytest.raises(TypeError, match="Unsupported engine type"):
+
+        @transact
+        def test_func(conn=Inject(unsupported)):  # type: ignore
+            pass
+
+        test_func()
+
+
+# Test decorator without Inject parameter
+def test_connect_without_inject_parameter():
+    """Test that @connect works on functions without Inject parameter."""
+
+    @connect
+    def simple_function():
+        return "hello"
+
+    # Should just return the function as-is without wrapping
+    assert simple_function() == "hello"
+
+
+def test_transact_without_inject_parameter():
+    """Test that @transact works on functions without Inject parameter."""
+
+    @transact
+    def simple_function():
+        return "hello"
+
+    # Should just return the function as-is without wrapping
+    assert simple_function() == "hello"
+
+
+# Integration test combining both decorators
+def test_integration_connect_and_transact(sync_engine):
+    """Test integration of @connect and @transact decorators."""
+    fancy_engine = fancy(sync_engine)
+
+    @transact
+    def create_user(name: str, conn=Inject(fancy_engine)):
+        conn.execute(sa.insert(users).values(name=name))
+
+    @connect
+    def get_users(conn=Inject(fancy_engine)):
+        result = conn.execute(sa.select(users.c.name).order_by(users.c.name))
+        return [row[0] for row in result]
+
+    @transact
+    def create_multiple_users(names: list[str], conn=Inject(fancy_engine)):
+        for name in names:
+            create_user(name, conn=conn)
+
+    # Create users using nested decorators
+    create_multiple_users(["Alice", "Bob", "Charlie"])
+
+    # Verify all users were created
+    assert get_users() == ["Alice", "Bob", "Charlie"]
+
+
+@pytest.mark.asyncio
+async def test_async_integration_connect_and_transact(async_engine):
+    """Test async integration of @connect and @transact decorators."""
+    fancy_engine = fancy(async_engine)
+
+    @transact
+    async def create_user(name: str, conn=Inject(fancy_engine)):
+        await conn.execute(sa.insert(users).values(name=name))
+
+    @connect
+    async def get_users(conn=Inject(fancy_engine)):
+        result = await conn.execute(sa.select(users.c.name).order_by(users.c.name))
+        return [row[0] for row in result]
+
+    @transact
+    async def create_multiple_users(names: list[str], conn=Inject(fancy_engine)):
+        for name in names:
+            await create_user(name, conn=conn)
+
+    # Create users using nested decorators
+    await create_multiple_users(["Alice", "Bob", "Charlie"])
+
+    # Verify all users were created
+    assert await get_users() == ["Alice", "Bob", "Charlie"]

{sqla_fancy_core-1.1.1 → sqla_fancy_core-1.1.2}/uv.lock

@@ -2968,7 +2968,7 @@ wheels = [
 
 [[package]]
 name = "sqla-fancy-core"
-version = "1.1.1"
+version = "1.1.2"
 source = { editable = "." }
 dependencies = [
     { name = "sqlalchemy" },