sqla-fancy-core 1.0.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

sqla_fancy_core-1.2.2.dist-info/METADATA

@@ -0,0 +1,486 @@
+Metadata-Version: 2.4
+Name: sqla-fancy-core
+Version: 1.2.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: 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
+
+A collection of type-safe, async friendly, and un-opinionated enhancements to SQLAlchemy Core that works well with mordern web servers.
+
+**Why?**
+
+- ORMs are magical, but it's not always a feature. Sometimes, we crave for familiar.
+- SQLAlchemy Core is powerful but `table.c.column` breaks static type checking and has runtime overhead. This library provides a better way to define tables while keeping all of SQLAlchemy's flexibility. See [Table Factory](#table-factory).
+- The idea of sessions can get feel too magical and opinionated. This library removes the magic and opinions and takes you to back to familiar transactions's territory, providing multiple un-opinionated APIs to deal with it. See [Wrappers](#fancy-engine-wrappers) and [Decorators](#decorators-inject-connect-transact).
+
+**Demos:**
+
+- [FastAPI - sqla-fancy-core example app](https://github.com/sayanarijit/fastapi-sqla-fancy-core-example-app).
+
+## Table factory
+
+Define tables with static column references## Target audience
+
+For production use by developers who prefer query builders over ORMs, need robust sync/async support, and want type-safe, readable code.
+
+**Example:**
+
+Define tables:
+
+```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")
+```
+
+For complex scenarios, define columns explicitly:
+
+```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()))
+```
+
+Create 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)
+```
+
+Perform CRUD operations:
+
+```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
+
+Simplify connection and transaction management. The `fancy()` function wraps a SQLAlchemy engine and provides:
+
+- `x(conn, query)`: Execute query with optional connection
+- `tx(conn, query)`: Execute query in transaction
+- `atomic()`: Context manager for transaction scope
+- `ax(query)`: Execute inside `atomic()` context (raises `AtomicContextError` outside)
+- `atx(query)`: Auto-transactional (reuses `atomic()` if present, or creates new transaction)
+
+### Basic Examples
+
+**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
+```
+
+### Using the atomic() Context Manager
+
+Group operations in a single transaction. Nested `atomic()` contexts share the outer connection.
+
+**Sync Example:**
+
+```python
+import sqlalchemy as sa
+from sqla_fancy_core import fancy, TableFactory
+
+tf = TableFactory()
+
+class User:
+    id = tf.auto_id()
+    name = tf.string("name")
+    Table = tf("users")
+
+engine = sa.create_engine("sqlite:///:memory:")
+tf.metadata.create_all(engine)
+fancy_engine = fancy(engine)
+
+# Group operations in one transaction
+with fancy_engine.atomic():
+    fancy_engine.ax(sa.insert(User.Table).values(name="Alice"))
+    fancy_engine.ax(sa.insert(User.Table).values(name="Bob"))
+    result = fancy_engine.ax(sa.select(sa.func.count()).select_from(User.Table))
+    count = result.scalar_one()
+    assert count == 2
+```
+
+**Async Example:**
+
+```python
+import sqlalchemy as sa
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqla_fancy_core import fancy, TableFactory
+
+tf = TableFactory()
+
+class User:
+    id = tf.auto_id()
+    name = tf.string("name")
+    Table = tf("users")
+
+async def run_example():
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    async with engine.begin() as conn:
+        await conn.run_sync(tf.metadata.create_all)
+
+    fancy_engine = fancy(engine)
+
+    async with fancy_engine.atomic():
+        await fancy_engine.ax(sa.insert(User.Table).values(name="Alice"))
+        await fancy_engine.ax(sa.insert(User.Table).values(name="Bob"))
+        result = await fancy_engine.ax(sa.select(sa.func.count()).select_from(User.Table))
+        count = result.scalar_one()
+        assert count == 2
+```
+
+**Key Points:**
+
+- `ax()` requires `atomic()` context
+- `atx()` auto-manages transactions (safe inside or outside `atomic()`)
+- Nested `atomic()` contexts share connections
+- Auto-commit on success, auto-rollback on exception
+
+### ax vs atx vs tx
+
+- `ax(q)`: Requires `atomic()` context. For batch operations.
+- `atx(q)`: Fire-and-forget with transaction. Reuses outer `atomic()` context if any, or creates new transaction.
+- `tx(conn, q)`: Low-level. Uses provided `conn`, or outer `atomic()` context if any, or creates new transactional connection.
+
+## Decorators: Inject, connect, transact
+
+Keep functions connection-agnostic with decorator-based injection.
+
+**Components:**
+
+- `Inject(engine)`: Marks parameter for connection injection
+- `@connect`: Ensures live connection (no transaction by default)
+- `@transact`: Ensures transactional connection
+
+Use `@connect` for read-only operations. Use `@transact` for writes.
+
+### 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)
+
+@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
+
+@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
+
+# With an explicit transaction
+with engine.begin() as txn:
+    create_user("bob", conn=txn)
+    assert get_user_count(conn=txn) == 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))
+
+# 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
+```
+
+Works with dependency injection frameworks like 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 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))
+```
+
+## With Pydantic Validation
+
+Integrate with Pydantic for 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.2.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+sqla_fancy_core/__init__.py,sha256=2Zxz2oM30Vv0_JJOMulUmts1nfag8mPyRAT7o8MW-pY,313
+sqla_fancy_core/decorators.py,sha256=VhkYf5x6qwcQnc8QCuUzKPQxMI3tNNGM7nVSPUqMkPw,6649
+sqla_fancy_core/factories.py,sha256=EgOhc15rCo9GyIuSNhuoB1pJ6lXx_UtRR5y9hh2lEtM,6326
+sqla_fancy_core/wrappers.py,sha256=tQXyo84-7-8Mqc-tqDUwQsFpnNm4AeEeiGCLpLDWI_c,15090
+sqla_fancy_core-1.2.2.dist-info/METADATA,sha256=-Ypz729sAc655XVtrB68TPbbnRiX8cT1NxmHCBCD1EM,14635
+sqla_fancy_core-1.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqla_fancy_core-1.2.2.dist-info/licenses/LICENSE,sha256=XcYXJ0ipvwOn-nzko6p_xoCCbke8tAhmlIN04rUZDLk,1068
+sqla_fancy_core-1.2.2.dist-info/RECORD,,

sqla_fancy_core-1.0.0.dist-info/METADATA

@@ -1,192 +0,0 @@
-Metadata-Version: 2.4
-Name: sqla-fancy-core
-Version: 1.0.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: 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 = next(conn.execute(qry).mappings())
-    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 = next(conn.execute(qry).mappings())
-    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).fetchall()
-    assert result == [("John Doe", "My Book")], result
-
-# 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 = next(conn.execute(qry).mappings())
-    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 = next(conn.execute(qry).mappings())
-    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).fetchall()
-    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.0.dist-info/RECORD

@@ -1,5 +0,0 @@
-sqla_fancy_core/__init__.py,sha256=GwPbjEPhM-mxFcsjZizCQ9dnUNgqBswCfwrI_u-JVfc,6376
-sqla_fancy_core-1.0.0.dist-info/METADATA,sha256=1UBn6tJ7EK6TXKBdq6gUWtzStIqeHS3lsKDb9pkZBCE,5671
-sqla_fancy_core-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqla_fancy_core-1.0.0.dist-info/licenses/LICENSE,sha256=XcYXJ0ipvwOn-nzko6p_xoCCbke8tAhmlIN04rUZDLk,1068
-sqla_fancy_core-1.0.0.dist-info/RECORD,,