sqla-fancy-core 1.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

sqla_fancy_core/__init__.py

@@ -1,159 +1,5 @@
 """SQLAlchemy core, but fancier."""
 
-from typing import Optional, Union, overload
-
-import sqlalchemy as sa
-
-
-class TableFactory:
-    """A factory for creating SQLAlchemy columns with default values."""
-
-    def __init__(self, metadata: Optional[sa.MetaData] = None):
-        """Initialize the factory with default values."""
-        if metadata is None:
-            self.metadata = sa.MetaData()
-        else:
-            self.metadata = metadata
-        self.c = []
-
-    def col(self, *args, **kwargs) -> sa.Column:
-        col = sa.Column(*args, **kwargs)
-        return self(col)
-
-    def integer(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.Integer, *args, **kwargs)
-
-    def string(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.String, *args, **kwargs)
-
-    def text(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.Text, *args, **kwargs)
-
-    def float(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.Float, *args, **kwargs)
-
-    def numeric(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.Numeric, *args, **kwargs)
-
-    def bigint(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.BigInteger, *args, **kwargs)
-
-    def smallint(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.SmallInteger, *args, **kwargs)
-
-    def timestamp(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.TIMESTAMP, *args, **kwargs)
-
-    def date(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.Date, *args, **kwargs)
-
-    def datetime(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.DateTime, *args, **kwargs)
-
-    def today(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.date(name, default=sa.func.now(), *args, **kwargs)
-
-    def time(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.Time, *args, **kwargs)
-
-    def timenow(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.time(name, default=sa.func.now(), *args, **kwargs)
-
-    def now(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.datetime(name, default=sa.func.now(), *args, **kwargs)
-
-    def boolean(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.Boolean, *args, **kwargs)
-
-    def true(self, name: str, *args, **kwargs):
-        return self.boolean(name, default=True, *args, **kwargs)
-
-    def false(self, name: str, *args, **kwargs):
-        return self.boolean(name, default=False, *args, **kwargs)
-
-    def foreign_key(self, name: str, ref: Union[str, sa.Column], *args, **kwargs):
-        return self.col(name, sa.ForeignKey(ref), *args, **kwargs)
-
-    def enum(self, name: str, enum: type, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.Enum(enum), *args, **kwargs)
-
-    def json(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.JSON, *args, **kwargs)
-
-    def array(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.col(name, sa.ARRAY, *args, **kwargs)
-
-    def array_int(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.Integer, *args, **kwargs)
-
-    def array_str(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.String, *args, **kwargs)
-
-    def array_text(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.Text, *args, **kwargs)
-
-    def array_float(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.Float, *args, **kwargs)
-
-    def array_numeric(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.Numeric, *args, **kwargs)
-
-    def array_bigint(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.BigInteger, *args, **kwargs)
-
-    def array_smallint(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.SmallInteger, *args, **kwargs)
-
-    def array_timestamp(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.TIMESTAMP, *args, **kwargs)
-
-    def array_date(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.Date, *args, **kwargs)
-
-    def array_datetime(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.DateTime, *args, **kwargs)
-
-    def array_time(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.Time, *args, **kwargs)
-
-    def array_boolean(self, name: str, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.Boolean, *args, **kwargs)
-
-    def array_enum(self, name: str, enum: type, *args, **kwargs) -> sa.Column:
-        return self.array(name, sa.Enum(enum), *args, **kwargs)
-
-    def auto_id(self, name="id", *args, **kwargs) -> sa.Column:
-        return self.integer(
-            name, primary_key=True, index=True, autoincrement=True, *args, **kwargs
-        )
-
-    def updated_at(self, name="updated_at", *args, **kwargs) -> sa.Column:
-        return self.datetime(
-            name, default=sa.func.now(), onupdate=sa.func.now(), *args, **kwargs
-        )
-
-    def created_at(self, name="created_at", *args, **kwargs) -> sa.Column:
-        return self.datetime(name, default=sa.func.now(), *args, **kwargs)
-
-    @overload
-    def __call__(self, arg1: str, *args, **kwargs) -> sa.Table: ...
-    @overload
-    def __call__(self, arg1: sa.Column, *args, **kwargs) -> sa.Column: ...
-    @overload
-    def __call__(self, arg1: sa.Table, *args, **kwargs) -> sa.Table: ...
-    def __call__(self, arg1, *args, **kwargs):
-        if isinstance(arg1, str):
-            cols = self.c
-            self.c = []
-            return sa.Table(arg1, self.metadata, *args, *cols, **kwargs)
-        elif isinstance(arg1, sa.Column):
-            arg1.info["args"] = args
-            arg1.info["kwargs"] = kwargs
-            self.c.append(arg1)
-            return arg1
-        elif isinstance(arg1, sa.Table):
-            cols = self.c
-            self.c = []
-            return sa.Table(arg1.name, self.metadata, *args, *cols, **kwargs)
-        else:
-            raise TypeError(f"Expected a string or Column, got {type(arg1).__name__}")
+from sqla_fancy_core.factories import TableFactory  # noqa
+from sqla_fancy_core.wrappers import FancyEngineWrapper, AsyncFancyEngineWrapper, fancy  # noqa
+from sqla_fancy_core.decorators import transact, Inject  # noqa

sqla_fancy_core/decorators.py

@@ -0,0 +1,160 @@
+"""Some decorators for fun times with SQLAlchemy core."""
+
+import functools
+import inspect
+from typing import Union, overload
+
+import sqlalchemy as sa
+from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine
+
+EngineType = Union[sa.engine.Engine, AsyncEngine]
+
+
+class _Injectable:
+    def __init__(self, engine: EngineType):
+        self.engine = engine
+
+
+@overload
+def Inject(engine: sa.Engine) -> sa.Connection: ...
+@overload
+def Inject(engine: AsyncEngine) -> AsyncConnection: ...
+def Inject(engine: EngineType):  # type: ignore
+    """A marker class for dependency injection."""
+    return _Injectable(engine)
+
+
+def transact(func):
+    """A decorator that provides a transactional context.
+
+    If the decorated function is called with a connection object, that
+    connection is used. Otherwise, a new transaction is started from the
+    engine, and the new connection is injected to the function.
+
+    Example: ::
+        @transact
+        def create_user(name: str, conn: sa.Connection = Inject(engine)):
+            conn.execute(...)
+
+        # This will create a new transaction
+        create_user("test")
+
+        # This will use the existing connection
+        with engine.connect() as conn:
+            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():
+        if param.default is not inspect.Parameter.empty and isinstance(
+            param.default, _Injectable
+        ):
+            inject_param_name = name
+            break
+    if inject_param_name is None:
+        return func  # No injection needed
+
+    engine = sig.parameters[inject_param_name].default.engine
+    is_async = isinstance(engine, AsyncEngine)
+
+    if is_async:
+
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            conn = kwargs.get(inject_param_name)
+            if isinstance(conn, AsyncConnection):
+                if conn.in_transaction():
+                    return await func(*args, **kwargs)
+                else:
+                    async with conn.begin():
+                        return await func(*args, **kwargs)
+            else:
+                async with engine.begin() as conn:
+                    kwargs[inject_param_name] = conn
+                    return await func(*args, **kwargs)
+
+        return async_wrapper
+
+    else:
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            conn = kwargs.get(inject_param_name)
+            if isinstance(conn, sa.Connection):
+                if conn.in_transaction():
+                    return func(*args, **kwargs)
+                else:
+                    with conn.begin():
+                        return func(*args, **kwargs)
+            else:
+                with engine.begin() as conn:
+                    kwargs[inject_param_name] = conn
+                    return func(*args, **kwargs)
+
+        return sync_wrapper
+
+
+def connect(func):
+    """A decorator that provides a connection context.
+
+    If the decorated function is called with a connection object, that
+    connection is used. Otherwise, a new connection is created from the
+    engine, and the new connection is injected to the function.
+
+    Example: ::
+        @connect
+        def get_user_count(conn: sa.Connection = Inject(engine)) -> int:
+            return conn.execute(...).scalar_one()
+
+        # This will create a new connection
+        count = get_user_count()
+
+        # This will use the existing connection
+        with engine.connect() as conn:
+            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():
+        if param.default is not inspect.Parameter.empty and isinstance(
+            param.default, _Injectable
+        ):
+            inject_param_name = name
+            break
+    if inject_param_name is None:
+        return func  # No injection needed
+
+    engine = sig.parameters[inject_param_name].default.engine
+    is_async = isinstance(engine, AsyncEngine)
+
+    if is_async:
+
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            conn = kwargs.get(inject_param_name)
+            if isinstance(conn, AsyncConnection):
+                return await func(*args, **kwargs)
+            else:
+                async with engine.connect() as conn:
+                    kwargs[inject_param_name] = conn
+                    return await func(*args, **kwargs)
+
+        return async_wrapper
+
+    else:
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            conn = kwargs.get(inject_param_name)
+            if isinstance(conn, sa.Connection):
+                return func(*args, **kwargs)
+            else:
+                with engine.connect() as conn:
+                    kwargs[inject_param_name] = conn
+                    return func(*args, **kwargs)
+
+        return sync_wrapper

sqla_fancy_core/factories.py

@@ -0,0 +1,156 @@
+"""Some factories for fun times with SQLAlchemy core."""
+
+from typing import Optional, Union, overload
+
+import sqlalchemy as sa
+
+
+class TableFactory:
+    """A factory for creating SQLAlchemy columns with default values."""
+
+    def __init__(self, metadata: Optional[sa.MetaData] = None):
+        """Initialize the factory with default values."""
+        if metadata is None:
+            self.metadata = sa.MetaData()
+        else:
+            self.metadata = metadata
+        self.c = []
+
+    def col(self, *args, **kwargs) -> sa.Column:
+        col = sa.Column(*args, **kwargs)
+        return self(col)
+
+    def integer(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.Integer, *args, **kwargs)
+
+    def string(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.String, *args, **kwargs)
+
+    def text(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.Text, *args, **kwargs)
+
+    def float(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.Float, *args, **kwargs)
+
+    def numeric(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.Numeric, *args, **kwargs)
+
+    def bigint(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.BigInteger, *args, **kwargs)
+
+    def smallint(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.SmallInteger, *args, **kwargs)
+
+    def timestamp(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.TIMESTAMP, *args, **kwargs)
+
+    def date(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.Date, *args, **kwargs)
+
+    def datetime(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.DateTime, *args, **kwargs)
+
+    def today(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.date(name, default=sa.func.now(), *args, **kwargs)
+
+    def time(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.Time, *args, **kwargs)
+
+    def timenow(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.time(name, default=sa.func.now(), *args, **kwargs)
+
+    def now(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.datetime(name, default=sa.func.now(), *args, **kwargs)
+
+    def boolean(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.Boolean, *args, **kwargs)
+
+    def true(self, name: str, *args, **kwargs):
+        return self.boolean(name, default=True, *args, **kwargs)
+
+    def false(self, name: str, *args, **kwargs):
+        return self.boolean(name, default=False, *args, **kwargs)
+
+    def foreign_key(self, name: str, ref: Union[str, sa.Column], *args, **kwargs):
+        return self.col(name, sa.ForeignKey(ref), *args, **kwargs)
+
+    def enum(self, name: str, enum: type, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.Enum(enum), *args, **kwargs)
+
+    def json(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.JSON, *args, **kwargs)
+
+    def array(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.col(name, sa.ARRAY, *args, **kwargs)
+
+    def array_int(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.Integer, *args, **kwargs)
+
+    def array_str(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.String, *args, **kwargs)
+
+    def array_text(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.Text, *args, **kwargs)
+
+    def array_float(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.Float, *args, **kwargs)
+
+    def array_numeric(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.Numeric, *args, **kwargs)
+
+    def array_bigint(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.BigInteger, *args, **kwargs)
+
+    def array_smallint(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.SmallInteger, *args, **kwargs)
+
+    def array_timestamp(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.TIMESTAMP, *args, **kwargs)
+
+    def array_date(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.Date, *args, **kwargs)
+
+    def array_datetime(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.DateTime, *args, **kwargs)
+
+    def array_time(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.Time, *args, **kwargs)
+
+    def array_boolean(self, name: str, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.Boolean, *args, **kwargs)
+
+    def array_enum(self, name: str, enum: type, *args, **kwargs) -> sa.Column:
+        return self.array(name, sa.Enum(enum), *args, **kwargs)
+
+    def auto_id(self, name="id", *args, **kwargs) -> sa.Column:
+        return self.integer(
+            name, primary_key=True, index=True, autoincrement=True, *args, **kwargs
+        )
+
+    def updated_at(self, name="updated_at", *args, **kwargs) -> sa.Column:
+        return self.datetime(
+            name, default=sa.func.now(), onupdate=sa.func.now(), *args, **kwargs
+        )
+
+    def created_at(self, name="created_at", *args, **kwargs) -> sa.Column:
+        return self.datetime(name, default=sa.func.now(), *args, **kwargs)
+
+    @overload
+    def __call__(self, arg1: str, *args, **kwargs) -> sa.Table: ...
+    @overload
+    def __call__(self, arg1: sa.Column, *args, **kwargs) -> sa.Column: ...
+    @overload
+    def __call__(self, arg1: sa.Table, *args, **kwargs) -> sa.Table: ...
+    def __call__(self, arg1, *args, **kwargs):
+        if isinstance(arg1, sa.Column):
+            arg1.info["args"] = args
+            arg1.info["kwargs"] = kwargs
+            self.c.append(arg1)
+            return arg1
+        elif isinstance(arg1, Union[str, sa.Table]):
+            cols = self.c
+            tablename = arg1.name if isinstance(arg1, sa.Table) else arg1
+            self.c = []
+            return sa.Table(tablename, self.metadata, *args, *cols, **kwargs)
+        else:
+            raise TypeError(f"Expected a string or Column, got {type(arg1).__name__}")

sqla_fancy_core/wrappers.py

@@ -0,0 +1,239 @@
+"""Some wrappers for fun times with SQLAlchemy core."""
+
+from typing import Any, Optional, TypeVar, overload
+
+from sqlalchemy import Connection, CursorResult, Engine, Executable
+from sqlalchemy.engine.interfaces import (
+    CoreExecuteOptionsParameter,
+    _CoreAnyExecuteParams,
+)
+from sqlalchemy.ext.asyncio import (
+    AsyncConnection,
+    AsyncEngine,
+)
+from sqlalchemy.sql.selectable import TypedReturnsRows
+
+_T = TypeVar("_T", bound=Any)
+
+
+class FancyEngineWrapper:
+    """A wrapper around SQLAlchemy Engine with additional features."""
+
+    def __init__(self, engine: Engine) -> None:
+        self.engine = engine
+
+    @overload
+    def x(
+        self,
+        connection: Optional[Connection],
+        statement: TypedReturnsRows[_T],
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[_T]: ...
+    @overload
+    def x(
+        self,
+        connection: Optional[Connection],
+        statement: Executable,
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[Any]: ...
+    def x(
+        self,
+        connection: Optional[Connection],
+        statement: Executable,
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[Any]:
+        """Connect to the database, execute the query, and return the result.
+
+        If a connection is provided, use it; otherwise, create a new one.
+        """
+        if connection:
+            return connection.execute(
+                statement, parameters, execution_options=execution_options
+            )
+        else:
+            with self.engine.connect() as connection:
+                return connection.execute(
+                    statement, parameters, execution_options=execution_options
+                )
+
+    @overload
+    def tx(
+        self,
+        connection: Optional[Connection],
+        statement: TypedReturnsRows[_T],
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[_T]: ...
+    @overload
+    def tx(
+        self,
+        connection: Optional[Connection],
+        statement: Executable,
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[Any]: ...
+    def tx(
+        self,
+        connection: Optional[Connection],
+        statement: Executable,
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[Any]:
+        """Begin a transaction, execute the query, and return the result.
+
+        If a connection is provided, use it; otherwise, create a new one.
+        """
+        if connection:
+            if connection.in_transaction():
+                # Transaction is already active
+                return connection.execute(
+                    statement, parameters, execution_options=execution_options
+                )
+            else:
+                with connection.begin():
+                    return connection.execute(
+                        statement, parameters, execution_options=execution_options
+                    )
+        else:
+            with self.engine.begin() as connection:
+                return connection.execute(
+                    statement, parameters, execution_options=execution_options
+                )
+
+
+class AsyncFancyEngineWrapper:
+    """A wrapper around SQLAlchemy AsyncEngine with additional features."""
+
+    def __init__(self, engine: AsyncEngine) -> None:
+        self.engine = engine
+
+    @overload
+    async def x(
+        self,
+        connection: Optional[AsyncConnection],
+        statement: TypedReturnsRows[_T],
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[_T]: ...
+    @overload
+    async def x(
+        self,
+        connection: Optional[AsyncConnection],
+        statement: Executable,
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[Any]: ...
+    async def x(
+        self,
+        connection: Optional[AsyncConnection],
+        statement: Executable,
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[Any]:
+        """Connect to the database, execute the query, and return the result.
+
+        If a connection is provided, use it; otherwise, create a new one.
+        """
+        if connection:
+            return await connection.execute(
+                statement, parameters, execution_options=execution_options
+            )
+        else:
+            async with self.engine.connect() as connection:
+                return await connection.execute(
+                    statement, parameters, execution_options=execution_options
+                )
+
+    @overload
+    async def tx(
+        self,
+        connection: Optional[AsyncConnection],
+        statement: TypedReturnsRows[_T],
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[_T]: ...
+    @overload
+    async def tx(
+        self,
+        connection: Optional[AsyncConnection],
+        statement: Executable,
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[Any]: ...
+    async def tx(
+        self,
+        connection: Optional[AsyncConnection],
+        statement: Executable,
+        parameters: Optional[_CoreAnyExecuteParams] = None,
+        *,
+        execution_options: Optional[CoreExecuteOptionsParameter] = None,
+    ) -> CursorResult[Any]:
+        """Execute the query within a transaction and return the result.
+
+        If a connection is provided, use it; otherwise, create a new one.
+        """
+        if connection:
+            if connection.in_transaction():
+                return await connection.execute(
+                    statement, parameters, execution_options=execution_options
+                )
+            else:
+                async with connection.begin():
+                    return await connection.execute(
+                        statement, parameters, execution_options=execution_options
+                    )
+        else:
+            async with self.engine.begin() as connection:
+                return await connection.execute(
+                    statement, parameters, execution_options=execution_options
+                )
+
+
+@overload
+def fancy(obj: Engine, /) -> FancyEngineWrapper: ...
+@overload
+def fancy(obj: AsyncEngine, /) -> AsyncFancyEngineWrapper: ...
+def fancy(obj, /):
+    """Fancy engine wrapper makes the following syntax possible: ::
+
+    import sqlalchemy as sa
+
+    fancy_engine = fancy(sa.create_engine("sqlite:///:memory:"))
+
+    def handler(conn: sa.Connection | None = None):
+        # Execute a query outside of a transaction
+        result = fancy_engine.x(conn, sa.select(...))
+
+        # Execute a query within a transaction
+        result = fancy_engine.tx(conn, sa.insert(...))
+
+    # Using an explicit connection:
+    with fancy_engine.engine.connect() as conn:
+        handler(conn=conn)
+
+    # Using a dependency injection system:
+        handler(conn=dependency(transaction))  # Uses the provided transaction connection
+
+    # Or without a given connection (e.g. in IPython shell):
+        handler()
+    """
+    if isinstance(obj, Engine):
+        return FancyEngineWrapper(obj)
+    elif isinstance(obj, AsyncEngine):
+        return AsyncFancyEngineWrapper(obj)
+    else:
+        raise TypeError("Unsupported input type for fancy()")

sqla_fancy_core-1.1.0.dist-info/METADATA

@@ -0,0 +1,422 @@
+Metadata-Version: 2.4
+Name: sqla-fancy-core
+Version: 1.1.0
+Summary: SQLAlchemy core, but fancier
+Project-URL: Homepage, https://github.com/sayanarijit/sqla-fancy-core
+Author-email: Arijit Basu <sayanarijit@gmail.com>
+Maintainer-email: Arijit Basu <sayanarijit@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2023 Arijit Basu
+        
+        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: sql,sqlalchemy,sqlalchemy-core
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Requires-Dist: sqlalchemy
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: hatchling; extra == 'dev'
+Requires-Dist: ipython; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: aiosqlite; extra == 'test'
+Requires-Dist: fastapi; extra == 'test'
+Requires-Dist: flake8; extra == 'test'
+Requires-Dist: httpx; extra == 'test'
+Requires-Dist: pydantic; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'
+Requires-Dist: python-multipart; extra == 'test'
+Requires-Dist: sqlalchemy[asyncio]; extra == 'test'
+Description-Content-Type: text/markdown
+
+# sqla-fancy-core
+
+There are plenty of ORMs to choose from in Python world, but not many sql query makers for folks who prefer to stay close to the original SQL syntax, without sacrificing security and code readability. The closest, most mature and most flexible query maker you can find is SQLAlchemy core.
+
+But the syntax of defining tables and making queries has a lot of scope for improvement. For example, the `table.c.column` syntax is too dynamic, unreadable, and probably has performance impact too. It also doesn’t play along with static type checkers and linting tools.
+
+So here I present one attempt at getting the best out of SQLAlchemy core by changing the way we define tables.
+
+The table factory class it exposes, helps define tables in a way that eliminates the above drawbacks. Moreover, you can subclass it to add your preferred global defaults for columns (e.g. not null as default). Or specify custom column types with consistent naming (e.g. created_at).
+
+## Basic Usage
+
+First, let's define a table using the `TableFactory`.
+
+```python
+import sqlalchemy as sa
+from sqla_fancy_core import TableFactory
+
+tf = TableFactory()
+
+class Author:
+    id = tf.auto_id()
+    name = tf.string("name")
+    created_at = tf.created_at()
+    updated_at = tf.updated_at()
+
+    Table = tf("author")
+```
+
+The `TableFactory` provides a convenient way to define columns with common attributes. For more complex scenarios, you can define tables without losing type hints:
+
+```python
+class Book:
+    id = tf(sa.Column("id", sa.Integer, primary_key=True, autoincrement=True))
+    title = tf(sa.Column("title", sa.String(255), nullable=False))
+    author_id = tf(sa.Column("author_id", sa.Integer, sa.ForeignKey(Author.id)))
+    created_at = tf(
+        sa.Column(
+            "created_at",
+            sa.DateTime,
+            nullable=False,
+            server_default=sa.func.now(),
+        )
+    )
+    updated_at = tf(
+        sa.Column(
+            "updated_at",
+            sa.DateTime,
+            nullable=False,
+            server_default=sa.func.now(),
+            onupdate=sa.func.now(),
+        )
+    )
+
+    Table = tf(sa.Table("book", sa.MetaData()))
+```
+
+Now, let's create an engine and the tables.
+
+```python
+from sqlalchemy.ext.asyncio import create_async_engine
+
+# Create the engine
+engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+
+# Create the tables
+async with engine.begin() as conn:
+    await conn.run_sync(tf.metadata.create_all)
+```
+
+With the tables created, you can perform CRUD operations.
+
+### CRUD Operations
+
+Here's how you can interact with the database using the defined tables.
+
+```python
+async with engine.begin() as txn:
+    # Insert author
+    qry = (
+        sa.insert(Author.Table)
+        .values({Author.name: "John Doe"})
+        .returning(Author.id)
+    )
+    author = (await txn.execute(qry)).mappings().one()
+    author_id = author[Author.id]
+    assert author_id == 1
+
+    # Insert book
+    qry = (
+        sa.insert(Book.Table)
+        .values({Book.title: "My Book", Book.author_id: author_id})
+        .returning(Book.id)
+    )
+    book = (await txn.execute(qry)).mappings().one()
+    assert book[Book.id] == 1
+
+    # Query the data
+    qry = sa.select(Author.name, Book.title).join(
+        Book.Table,
+        Book.author_id == Author.id,
+    )
+    result = (await txn.execute(qry)).all()
+    assert result == [("John Doe", "My Book")], result
+```
+
+## Fancy Engine Wrappers
+
+`sqla-fancy-core` provides `fancy` engine wrappers that simplify database interactions by automatically managing connections and transactions. The `fancy` function wraps a SQLAlchemy `Engine` or `AsyncEngine` and returns a wrapper object with two primary methods:
+
+- `x(conn, query)`: Executes a query. It uses the provided `conn` if available, otherwise it creates a new connection.
+- `tx(conn, query)`: Executes a query within a transaction. It uses the provided `conn` if available, otherwise it creates a new connection and begins a transaction.
+
+This is particularly useful for writing connection-agnostic query functions.
+
+**Sync Example:**
+
+```python
+import sqlalchemy as sa
+from sqla_fancy_core import fancy
+
+engine = sa.create_engine("sqlite:///:memory:")
+fancy_engine = fancy(engine)
+
+def get_data(conn: sa.Connection | None = None):
+    return fancy_engine.tx(conn, sa.select(sa.literal(1))).scalar_one()
+
+# Without an explicit transaction
+assert get_data() == 1
+
+# With an explicit transaction
+with engine.begin() as conn:
+    assert get_data(conn) == 1
+```
+
+**Async Example:**
+
+```python
+import sqlalchemy as sa
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqla_fancy_core import fancy
+
+async def main():
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    fancy_engine = fancy(engine)
+
+    async def get_data(conn: sa.AsyncConnection | None = None):
+        result = await fancy_engine.x(conn, sa.select(sa.literal(1)))
+        return result.scalar_one()
+
+    # Without an explicit transaction
+    assert await get_data() == 1
+
+    # With an explicit transaction
+    async with engine.connect() as conn:
+        assert await get_data(conn) == 1
+```
+
+## Decorators: Inject, connect, transact
+
+When writing plain SQLAlchemy Core code, you often pass connections around and manage transactions manually. The decorators in `sqla-fancy-core` help you keep functions connection-agnostic and composable, while remaining explicit and safe.
+
+At the heart of it is `Inject(engine)`, a tiny marker used as a default parameter value to tell decorators where to inject a connection.
+
+- `Inject(engine)`: marks which parameter should receive a connection derived from the given engine.
+- `@connect`: ensures the injected parameter is a live connection. If you passed a connection explicitly, it will use that one as-is. Otherwise, it will open a new connection for the call and close it afterwards. No transaction is created by default.
+- `@transact`: ensures the injected parameter is inside a transaction. If you pass a connection already in a transaction, it reuses it; if you pass a connection outside a transaction, it starts one; if you pass nothing, it opens a new connection and begins a transaction for the duration of the call.
+
+All three work both for sync and async engines. The signatures remain the same — you only change the default value to `Inject(engine)`.
+
+### Quick reference
+
+- Prefer `@connect` for read-only operations or when you want to control commit/rollback yourself.
+- Prefer `@transact` to wrap a function in a transaction automatically and consistently.
+- You can still pass `conn=...` explicitly to either decorator to reuse an existing connection/transaction.
+
+### Sync examples
+
+```python
+import sqlalchemy as sa
+from sqla_fancy_core.decorators import Inject, connect, transact
+
+engine = sa.create_engine("sqlite:///:memory:")
+metadata = sa.MetaData()
+users = sa.Table(
+    "users",
+    metadata,
+    sa.Column("id", sa.Integer, primary_key=True, autoincrement=True),
+    sa.Column("name", sa.String),
+)
+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))
+
+create_user("alice")
+assert get_user_count() == 1
+
+# 3) Reuse an explicit connection or 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
+
+```python
+import sqlalchemy as sa
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncConnection
+from sqla_fancy_core.decorators import Inject, connect, transact
+
+engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+metadata = sa.MetaData()
+users = sa.Table(
+    "users",
+    metadata,
+    sa.Column("id", sa.Integer, primary_key=True, autoincrement=True),
+    sa.Column("name", sa.String),
+)
+
+async with engine.begin() as conn:
+    await conn.run_sync(metadata.create_all)
+
+@connect
+async def get_user_count(conn=Inject(engine)):
+    result = await conn.execute(sa.select(sa.func.count()).select_from(users))
+    return result.scalar_one()
+
+@transact
+async def create_user(name: str, conn=Inject(engine)):
+    await conn.execute(sa.insert(users).values(name=name))
+
+assert await get_user_count() == 0
+await create_user("carol")
+assert await get_user_count() == 1
+
+async with engine.connect() as conn:
+    await create_user("dave", conn=conn)
+    assert await get_user_count(conn=conn) == 2
+```
+
+### Works with dependency injection frameworks
+
+These decorators pair nicely with frameworks like FastAPI. You can keep a single function that works both inside DI (with an injected connection) and outside it (self-managed).
+
+Sync example with FastAPI:
+
+```python
+from typing import Annotated
+from fastapi import Depends, FastAPI, Form
+import sqlalchemy as sa
+from sqla_fancy_core.decorators import Inject, transact
+
+app = FastAPI()
+
+def get_transaction():
+    with engine.begin() as conn:
+        yield conn
+
+@transact
+@app.post("/create-user")
+def create_user(
+    name: Annotated[str, Form(...)],
+    conn: Annotated[sa.Connection, Depends(get_transaction)] = Inject(engine),
+):
+    conn.execute(sa.insert(users).values(name=name))
+
+# Works outside FastAPI too — starts its own transaction
+create_user(name="outside fastapi")
+```
+
+Async example with FastAPI:
+
+```python
+from typing import Annotated
+from fastapi import Depends, FastAPI, Form
+from sqlalchemy.ext.asyncio import AsyncConnection
+import sqlalchemy as sa
+from sqla_fancy_core.decorators import Inject, transact
+
+app = FastAPI()
+
+async def get_transaction():
+    async with engine.begin() as conn:
+        yield conn
+
+@transact
+@app.post("/create-user")
+async def create_user(
+    name: Annotated[str, Form(...)],
+    conn: Annotated[AsyncConnection, Depends(get_transaction)] = Inject(engine),
+):
+    await conn.execute(sa.insert(users).values(name=name))
+```
+
+Notes:
+
+- `@connect` never starts a transaction by itself; `@transact` ensures one.
+- Passing an explicit `conn` always wins — the decorators simply adapt to what you give them.
+- The injection marker keeps your function signatures clean and type-checker friendly.
+
+## With Pydantic Validation
+
+You can integrate `sqla-fancy-core` with Pydantic for data validation.
+
+```python
+from typing import Any
+import sqlalchemy as sa
+from pydantic import BaseModel, Field
+import pytest
+
+from sqla_fancy_core import TableFactory
+
+tf = TableFactory()
+
+def field(col, default: Any = ...) -> Field:
+    return col.info["kwargs"]["field"](default)
+
+# Define a table
+class User:
+    name = tf(
+        sa.Column("name", sa.String),
+        field=lambda default: Field(default, max_length=5),
+    )
+    Table = tf("author")
+
+# Define a pydantic schema
+class CreateUser(BaseModel):
+    name: str = field(User.name)
+
+# Define a pydantic schema
+class UpdateUser(BaseModel):
+    name: str | None = field(User.name, None)
+
+assert CreateUser(name="John").model_dump() == {"name": "John"}
+assert UpdateUser(name="John").model_dump() == {"name": "John"}
+assert UpdateUser().model_dump(exclude_unset=True) == {}
+
+with pytest.raises(ValueError):
+    CreateUser()
+with pytest.raises(ValueError):
+    UpdateUser(name="John Doe")
+```
+
+## Target audience
+
+Production. For folks who prefer query maker over ORM, looking for a robust sync/async driver integration, wanting to keep code readable and secure.
+
+## Comparison with other projects:
+
+**Peewee**: No type hints. Also, no official async support.
+
+**Piccolo**: Tight integration with drivers. Very opinionated. Not as flexible or mature as sqlalchemy core.
+
+**Pypika**: Doesn’t prevent sql injection by default. Hence can be considered insecure.
+
+**Raw string queries with placeholders**: sacrifices code readability, and prone to sql injection if one forgets to use placeholders.
+
+**Other ORMs**: They are full blown ORMs, not query makers.

sqla_fancy_core-1.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+sqla_fancy_core/__init__.py,sha256=iCfZrKbdoAG65CeHGducjiA1p4zYLgFSrxGDzQEhM8U,256
+sqla_fancy_core/decorators.py,sha256=0UlOL2MUAJq3Rv3hE7mLspvrZDX16f2pm_yh1mLgQWQ,5056
+sqla_fancy_core/factories.py,sha256=EgOhc15rCo9GyIuSNhuoB1pJ6lXx_UtRR5y9hh2lEtM,6326
+sqla_fancy_core/wrappers.py,sha256=TesGKm9ddsd7dJwbkonZPl46Huvqeh7AfUwB623qRwA,8165
+sqla_fancy_core-1.1.0.dist-info/METADATA,sha256=1imY4gioOlMMTxS3GBit_-eUSGz71_ArMl9D7WWMxxU,14473
+sqla_fancy_core-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqla_fancy_core-1.1.0.dist-info/licenses/LICENSE,sha256=XcYXJ0ipvwOn-nzko6p_xoCCbke8tAhmlIN04rUZDLk,1068
+sqla_fancy_core-1.1.0.dist-info/RECORD,,

sqla_fancy_core-1.0.2.dist-info/METADATA

@@ -1,160 +0,0 @@
-Metadata-Version: 2.4
-Name: sqla-fancy-core
-Version: 1.0.2
-Summary: SQLAlchemy core, but fancier
-Project-URL: Homepage, https://github.com/sayanarijit/sqla-fancy-core
-Author-email: Arijit Basu <sayanarijit@gmail.com>
-Maintainer-email: Arijit Basu <sayanarijit@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2023 Arijit Basu
-        
-        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: sql,sqlalchemy,sqlalchemy-core
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.7
-Requires-Dist: sqlalchemy
-Provides-Extra: test
-Requires-Dist: flake8; extra == 'test'
-Requires-Dist: pydantic; extra == 'test'
-Requires-Dist: pytest; extra == 'test'
-Description-Content-Type: text/markdown
-
-# sqla-fancy-core
-
-SQLAlchemy core, but fancier.
-
-### Basic Usage
-
-```python
-import sqlalchemy as sa
-
-from sqla_fancy_core import TableFactory
-
-tf = TableFactory()
-
-# Define a table
-class Author:
-    id = tf.auto_id()
-    name = tf.string("name")
-    created_at = tf.created_at()
-    updated_at = tf.updated_at()
-
-    Table = tf("author")
-
-# Or define it without losing type hints
-class Book:
-    id = tf(sa.Column("id", sa.Integer, primary_key=True, autoincrement=True))
-    title = tf(sa.Column("title", sa.String(255), nullable=False))
-    author_id = tf(sa.Column("author_id", sa.Integer, sa.ForeignKey(Author.id)))
-    created_at = tf(
-        sa.Column(
-            "created_at",
-            sa.DateTime,
-            nullable=False,
-            server_default=sa.func.now(),
-        )
-    )
-    updated_at = tf(
-        sa.Column(
-            "updated_at",
-            sa.DateTime,
-            nullable=False,
-            server_default=sa.func.now(),
-            onupdate=sa.func.now(),
-        )
-    )
-
-    Table = tf(sa.Table("book", sa.MetaData()))
-
-# Create the tables
-engine = sa.create_engine("sqlite:///:memory:")
-tf.metadata.create_all(engine)
-
-with engine.connect() as conn:
-    # Insert author
-    qry = (
-        sa.insert(Author.Table)
-        .values({Author.name: "John Doe"})
-        .returning(Author.id)
-    )
-    author = conn.execute(qry).mappings().first()
-    author_id = author[Author.id]
-    assert author_id == 1
-
-    # Insert book
-    qry = (
-        sa.insert(Book.Table)
-        .values({Book.title: "My Book", Book.author_id: author_id})
-        .returning(Book.id)
-    )
-    book = conn.execute(qry).mappings().first()
-    assert book[Book.id] == 1
-
-    # Query the data
-    qry = sa.select(Author.name, Book.title).join(
-        Book.Table,
-        Book.author_id == Author.id,
-    )
-    result = conn.execute(qry).all()
-    assert result == [("John Doe", "My Book")], result
-```
-
-### With Pydantic Validation
-
-```python
-from typing import Any
-import sqlalchemy as sa
-from pydantic import BaseModel, Field
-
-from sqla_fancy_core import TableFactory
-
-tf = TableFactory()
-
-def field(col, default: Any = ...) -> Field:
-    return col.info["kwargs"]["field"](default)
-
-# Define a table
-class User:
-    name = tf(
-        sa.Column("name", sa.String),
-        field=lambda default: Field(default, max_length=5),
-    )
-    Table = tf("author")
-
-# Define a pydantic schema
-class CreateUser(BaseModel):
-    name: str = field(User.name)
-
-# Define a pydantic schema
-class UpdateUser(BaseModel):
-    name: str | None = field(User.name, None)
-
-assert CreateUser(name="John").model_dump() == {"name": "John"}
-assert UpdateUser(name="John").model_dump() == {"name": "John"}
-assert UpdateUser().model_dump(exclude_unset=True) == {}
-
-with pytest.raises(ValueError):
-    CreateUser()
-with pytest.raises(ValueError):
-    UpdateUser(name="John Doe")
-```

sqla_fancy_core-1.0.2.dist-info/RECORD

@@ -1,5 +0,0 @@
-sqla_fancy_core/__init__.py,sha256=BbhW9HwA-YvLUh_r9AIigqN4vAkdDBLf0b9rO5VnuhA,6378
-sqla_fancy_core-1.0.2.dist-info/METADATA,sha256=qkwA6GOVIS0rr0zeelQkV6AMV6AjPOSxsz7M9yQdFUY,4815
-sqla_fancy_core-1.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqla_fancy_core-1.0.2.dist-info/licenses/LICENSE,sha256=XcYXJ0ipvwOn-nzko6p_xoCCbke8tAhmlIN04rUZDLk,1068
-sqla_fancy_core-1.0.2.dist-info/RECORD,,