glyff-sqlite 0.12.0__py3-none-any.whl

glyff_sqlite/__init__.py

@@ -0,0 +1,7 @@
+from ._sqlite_client import SQLiteClient
+from ._sqlite_store import SQLiteSessionStore
+
+__all__ = [
+    "SQLiteClient",
+    "SQLiteSessionStore",
+]

glyff_sqlite/_sqlite_client.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import sqlite3
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+SQLiteUpdate = Callable[[bytes | None], bytes | None]
+
+
+@dataclass(frozen=True)
+class _Write:
+    value: bytes
+
+
+@dataclass(frozen=True)
+class _Delete:
+    pass
+
+
+@dataclass(frozen=True)
+class _Update:
+    fn: SQLiteUpdate
+
+
+_StagedOp = _Write | _Delete | _Update
+
+_VALID_SYNCHRONOUS_VALUES = {"OFF", "NORMAL", "FULL", "EXTRA"}
+
+
+class _SQLiteStagingBuffer:
+    __slots__ = ("ops",)
+
+    def __init__(self) -> None:
+        self.ops: dict[tuple[str, str], list[_StagedOp]] = {}
+
+    def clear(self) -> None:
+        self.ops.clear()
+
+
+class SQLiteClient:
+    """A generic SQLite-backed transactional key/value store.
+
+    Each record is identified by ``(namespace, key)`` and stored as a blob
+    in the ``records`` table. Operations are staged per-transaction and
+    committed atomically.
+    """
+
+    def __init__(
+        self,
+        database_path: str | Path,
+        *,
+        busy_timeout_ms: int = 30_000,
+        synchronous: str = "FULL",
+    ) -> None:
+        synchronous = synchronous.upper()
+        if synchronous not in _VALID_SYNCHRONOUS_VALUES:
+            valid = ", ".join(sorted(_VALID_SYNCHRONOUS_VALUES))
+            raise ValueError(f"synchronous must be one of: {valid}")
+
+        if str(database_path) == ":memory:":
+            raise ValueError(
+                "SQLiteClient does not support ':memory:' because it opens "
+                "a new connection per operation."
+            )
+
+        self._database_path = Path(database_path)
+        self._busy_timeout_ms = busy_timeout_ms
+        self._synchronous = synchronous
+        self._write_lock = asyncio.Lock()
+        self._current: contextvars.ContextVar[_SQLiteStagingBuffer | None] = (
+            contextvars.ContextVar("sqlite_client_staging", default=None)
+        )
+
+        self._database_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # -- Connection helpers ----------------------------------------------------
+
+    def _connect(self) -> sqlite3.Connection:
+        connection = sqlite3.connect(
+            self._database_path,
+            isolation_level=None,
+            timeout=self._busy_timeout_ms / 1000,
+            check_same_thread=False,
+        )
+        connection.execute(f"PRAGMA busy_timeout={self._busy_timeout_ms}")
+        connection.execute("PRAGMA journal_mode=WAL")
+        connection.execute(f"PRAGMA synchronous={self._synchronous}")
+        return connection
+
+    # -- Schema initialization -------------------------------------------------
+
+    def _initialize_schema_sync(self) -> None:
+        connection = self._connect()
+        in_transaction = False
+        try:
+            connection.execute("BEGIN IMMEDIATE")
+            in_transaction = True
+            connection.execute(
+                """
+                CREATE TABLE IF NOT EXISTS records (
+                    namespace TEXT NOT NULL,
+                    key TEXT NOT NULL,
+                    value BLOB NOT NULL,
+                    PRIMARY KEY (namespace, key)
+                )
+                """
+            )
+            connection.execute("COMMIT")
+            in_transaction = False
+        except BaseException:
+            if in_transaction:
+                try:
+                    connection.execute("ROLLBACK")
+                except sqlite3.Error:
+                    pass
+            raise
+        finally:
+            connection.close()
+
+    # -- Staging lifecycle -----------------------------------------------------
+
+    def begin_staging(self) -> tuple[contextvars.Token, _SQLiteStagingBuffer]:
+        staging = _SQLiteStagingBuffer()
+        token = self._current.set(staging)
+        return token, staging
+
+    def end_staging(self, token: contextvars.Token) -> None:
+        self._current.reset(token)
+
+    def _require_staging(self) -> _SQLiteStagingBuffer:
+        staging = self._current.get()
+        if staging is None:
+            raise RuntimeError("SQLiteClient write attempted outside a transaction.")
+        return staging
+
+    def _require_current_staging(self, expected: _SQLiteStagingBuffer) -> None:
+        if self._current.get() is not expected:
+            raise RuntimeError("Transaction closed out of order.")
+
+    # -- Staging API -----------------------------------------------------------
+
+    def stage_write(self, namespace: str, key: str, value: bytes) -> None:
+        staging = self._require_staging()
+        staging.ops.setdefault((namespace, key), []).append(_Write(value))
+
+    def stage_delete(self, namespace: str, key: str) -> None:
+        staging = self._require_staging()
+        staging.ops.setdefault((namespace, key), []).append(_Delete())
+
+    def stage_update(self, namespace: str, key: str, fn: SQLiteUpdate) -> None:
+        staging = self._require_staging()
+        staging.ops.setdefault((namespace, key), []).append(_Update(fn))
+
+    async def clear_staged(self) -> None:
+        self._require_staging().clear()
+
+    # -- Commit ----------------------------------------------------------------
+
+    async def commit_staged(self) -> None:
+        staging = self._require_staging()
+
+        if not staging.ops:
+            return
+
+        async with self._write_lock:
+            await asyncio.to_thread(self._commit_staged_sync, staging)
+
+        staging.clear()
+
+    def _commit_staged_sync(self, staging: _SQLiteStagingBuffer) -> None:
+        connection = self._connect()
+        in_transaction = False
+        try:
+            connection.execute("BEGIN IMMEDIATE")
+            in_transaction = True
+
+            for (namespace, key), ops in staging.ops.items():
+                current = self._read_value_sync(connection, namespace, key)
+                result = self._apply_ops(current, ops)
+
+                if result is None:
+                    connection.execute(
+                        "DELETE FROM records WHERE namespace = ? AND key = ?",
+                        (namespace, key),
+                    )
+                else:
+                    connection.execute(
+                        """INSERT INTO records (namespace, key, value)
+                           VALUES (?, ?, ?)
+                           ON CONFLICT(namespace, key) DO UPDATE SET value = excluded.value""",
+                        (namespace, key, result),
+                    )
+
+            connection.execute("COMMIT")
+            in_transaction = False
+        except BaseException:
+            if in_transaction:
+                try:
+                    connection.execute("ROLLBACK")
+                except sqlite3.Error:
+                    pass
+            raise
+        finally:
+            connection.close()
+
+    @staticmethod
+    def _apply_ops(data: bytes | None, ops: list[_StagedOp]) -> bytes | None:
+        current = data
+        for op in ops:
+            if isinstance(op, _Write):
+                current = op.value
+            elif isinstance(op, _Delete):
+                current = None
+            elif isinstance(op, _Update):
+                current = op.fn(current)
+            else:
+                raise TypeError(f"Unknown SQLite op: {op!r}")
+        return current
+
+    # -- Read / list_keys ------------------------------------------------------
+
+    async def read(
+        self, namespace: str, key: str, *, staged: bool = True
+    ) -> bytes | None:
+        committed = await asyncio.to_thread(self._read_committed_sync, namespace, key)
+
+        if staged:
+            staging = self._current.get()
+            if staging is not None:
+                ops = staging.ops.get((namespace, key))
+                if ops:
+                    committed = self._apply_ops(committed, ops)
+
+        return committed
+
+    def _read_committed_sync(self, namespace: str, key: str) -> bytes | None:
+        connection = self._connect()
+        try:
+            return self._read_value_sync(connection, namespace, key)
+        finally:
+            connection.close()
+
+    @staticmethod
+    def _read_value_sync(
+        connection: sqlite3.Connection, namespace: str, key: str
+    ) -> bytes | None:
+        row = connection.execute(
+            "SELECT value FROM records WHERE namespace = ? AND key = ?",
+            (namespace, key),
+        ).fetchone()
+        return row[0] if row else None
+
+    async def list_keys(
+        self, namespace: str, prefix: str = "", *, staged: bool = True
+    ) -> set[str]:
+        committed = await asyncio.to_thread(
+            self._list_committed_keys_sync, namespace, prefix
+        )
+
+        if staged:
+            staging = self._current.get()
+            if staging is not None:
+                for (ns, key), ops in staging.ops.items():
+                    if ns != namespace:
+                        continue
+                    if not key.startswith(prefix):
+                        continue
+                    final = self._apply_ops(
+                        self._read_committed_sync(namespace, key),
+                        ops,
+                    )
+                    if final is None:
+                        committed.discard(key)
+                    else:
+                        committed.add(key)
+
+        return committed
+
+    def _list_committed_keys_sync(self, namespace: str, prefix: str = "") -> set[str]:
+        connection = self._connect()
+        try:
+            if prefix:
+                rows = connection.execute(
+                    "SELECT key FROM records WHERE namespace = ? AND substr(key, 1, ?) = ?",
+                    (namespace, len(prefix), prefix),
+                ).fetchall()
+            else:
+                rows = connection.execute(
+                    "SELECT key FROM records WHERE namespace = ?",
+                    (namespace,),
+                ).fetchall()
+            return {row[0] for row in rows}
+        finally:
+            connection.close()
+
+    # -- Direct SQL access (for initialization / inspection) -------------------
+
+    async def read_sql(self, sql: str, *params: Any) -> list[tuple]:
+        return await asyncio.to_thread(self._read_sql_sync, sql, params)
+
+    def _read_sql_sync(self, sql: str, params: tuple[Any, ...]) -> list[tuple]:
+        connection = self._connect()
+        try:
+            return list(connection.execute(sql, params))
+        finally:
+            connection.close()
+
+    async def execute(self, sql: str, *params: Any) -> None:
+        async with self._write_lock:
+            await asyncio.to_thread(self._execute_sync, sql, params)
+
+    def _execute_sync(self, sql: str, params: tuple[Any, ...]) -> None:
+        connection = self._connect()
+        in_transaction = False
+        try:
+            connection.execute("BEGIN IMMEDIATE")
+            in_transaction = True
+            connection.execute(sql, params)
+            connection.execute("COMMIT")
+            in_transaction = False
+        except BaseException:
+            if in_transaction:
+                try:
+                    connection.execute("ROLLBACK")
+                except sqlite3.Error:
+                    pass
+            raise
+        finally:
+            connection.close()

glyff_sqlite/_sqlite_store.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import json
+import logging
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+from glyff import (
+    Execution,
+    ExecutionId,
+    ExecutionRecord,
+    ExecutionStatus,
+    SessionStore,
+    Transaction,
+)
+from glyff.serialization import JsonSerializer
+from glyff.serialization.constants import DEFAULT_ENCODING
+from glyff.store.utils import execution_id_to_path, path_to_execution_id
+
+from ._sqlite_client import SQLiteClient
+from ._transaction import _ClientTransaction
+
+logger = logging.getLogger(__name__)
+
+_EXECUTIONS_NAMESPACE = "executions"
+
+_STATUS_NAMES = {
+    ExecutionStatus.STARTED: "started",
+    ExecutionStatus.COMPLETED: "completed",
+    ExecutionStatus.FAILED: "failed",
+}
+_NAME_TO_STATUS = {v: k for k, v in _STATUS_NAMES.items()}
+
+
+def _to_stored_bytes(record: dict[str, Any]) -> bytes:
+    return json.dumps(record, ensure_ascii=False, sort_keys=True).encode(
+        DEFAULT_ENCODING
+    )
+
+
+def _from_stored_bytes(data: bytes | None) -> dict[str, Any] | None:
+    if data is None:
+        return None
+    return json.loads(data.decode(DEFAULT_ENCODING))
+
+
+def _make_stored(
+    status: ExecutionStatus,
+    result_json: str | None = None,
+    error: str | None = None,
+) -> bytes:
+    return _to_stored_bytes(
+        {
+            "status": _STATUS_NAMES[status],
+            "result_json": result_json,
+            "error": error,
+        }
+    )
+
+
+async def _to_record(
+    data: bytes,
+    return_type: type,
+    serializer: JsonSerializer,
+) -> ExecutionRecord:
+    stored = json.loads(data.decode(DEFAULT_ENCODING))
+    status = _NAME_TO_STATUS[stored["status"]]
+    result: Any | None = None
+    error: str | None = None
+    if status == ExecutionStatus.COMPLETED:
+        result_json = stored.get("result_json")
+        if result_json is not None:
+            result = await serializer.deserialize(
+                result_json.encode(DEFAULT_ENCODING), return_type
+            )
+    elif status == ExecutionStatus.FAILED:
+        error = stored.get("error") or ""
+    return ExecutionRecord(status=status, result=result, error=error)
+
+
+class _SQLiteExecution(Execution):
+    def __init__(
+        self,
+        client: SQLiteClient,
+        execution_id: ExecutionId,
+        serializer: JsonSerializer,
+    ) -> None:
+        self._client = client
+        self._key = execution_id_to_path(execution_id)
+        self._serializer = serializer
+
+    async def complete(self, value: object, return_type: type) -> None:
+        serialized_bytes = await self._serializer.serialize(value, return_type)
+        result_json = serialized_bytes.decode(DEFAULT_ENCODING)
+
+        def fn(data: bytes | None) -> bytes | None:
+            if data is None:
+                raise LookupError(f"Execution at {self._key} not found")
+            stored = json.loads(data.decode(DEFAULT_ENCODING))
+            if stored["status"] in (
+                _STATUS_NAMES[ExecutionStatus.COMPLETED],
+                _STATUS_NAMES[ExecutionStatus.FAILED],
+            ):
+                raise ValueError(
+                    f"Cannot complete execution at {self._key}: "
+                    f"already {stored['status']}"
+                )
+            stored["status"] = _STATUS_NAMES[ExecutionStatus.COMPLETED]
+            stored["result_json"] = result_json
+            return _to_stored_bytes(stored)
+
+        self._client.stage_update(_EXECUTIONS_NAMESPACE, self._key, fn)
+
+    async def fail(self, error: str) -> None:
+        def fn(data: bytes | None) -> bytes | None:
+            if data is None:
+                raise LookupError(f"Execution at {self._key} not found")
+            stored = json.loads(data.decode(DEFAULT_ENCODING))
+            if stored["status"] in (
+                _STATUS_NAMES[ExecutionStatus.COMPLETED],
+                _STATUS_NAMES[ExecutionStatus.FAILED],
+            ):
+                raise ValueError(
+                    f"Cannot fail execution at {self._key}: already {stored['status']}"
+                )
+            stored["status"] = _STATUS_NAMES[ExecutionStatus.FAILED]
+            stored["error"] = error
+            return _to_stored_bytes(stored)
+
+        self._client.stage_update(_EXECUTIONS_NAMESPACE, self._key, fn)
+
+
+class SQLiteSessionStore(SessionStore):
+    """A SQLite-backed SessionStore for durable local persistence.
+
+    All execution data is stored in the ``records`` table of ``SQLiteClient``
+    under the ``"executions"`` namespace. Mutations are staged via
+    ``stage_write`` / ``stage_update`` and committed atomically on commit.
+    """
+
+    def __init__(
+        self,
+        database_path: str | Path | None = None,
+        serializer: JsonSerializer | None = None,
+        *,
+        client: SQLiteClient | None = None,
+        busy_timeout_ms: int = 30_000,
+        synchronous: str = "FULL",
+    ):
+        if serializer is None:
+            raise TypeError("serializer is required.")
+
+        if client is None:
+            if database_path is None:
+                raise TypeError("database_path or client is required.")
+            client = SQLiteClient(
+                database_path,
+                busy_timeout_ms=busy_timeout_ms,
+                synchronous=synchronous,
+            )
+        elif database_path is not None:
+            raise TypeError("Pass either database_path or client, not both.")
+
+        self._client = client
+        self._serializer = serializer
+
+        self._client._initialize_schema_sync()
+
+    @property
+    def client(self) -> SQLiteClient:
+        return self._client
+
+    # -- SessionStore API ------------------------------------------------------
+
+    async def begin_transaction(self) -> Transaction:
+        return await _ClientTransaction(self._client).begin()
+
+    async def start_execution(self, execution_id: ExecutionId) -> Execution:
+        key = execution_id_to_path(execution_id)
+        existing = await self.get_execution_record(execution_id, type(None))
+        if existing is None:
+
+            def fn(data: bytes | None) -> bytes | None:
+                if data is not None:
+                    stored = json.loads(data.decode(DEFAULT_ENCODING))
+                    if stored["status"] in (
+                        _STATUS_NAMES[ExecutionStatus.COMPLETED],
+                        _STATUS_NAMES[ExecutionStatus.FAILED],
+                    ):
+                        raise ValueError(
+                            f"Cannot start execution {execution_id}: "
+                            f"already {stored['status']}"
+                        )
+                return _make_stored(ExecutionStatus.STARTED)
+
+            self._client.stage_update(_EXECUTIONS_NAMESPACE, key, fn)
+
+        return _SQLiteExecution(self._client, execution_id, self._serializer)
+
+    async def get_execution_record(
+        self, execution_id: ExecutionId, return_type: type
+    ) -> ExecutionRecord | None:
+        key = execution_id_to_path(execution_id)
+        data = await self._client.read(_EXECUTIONS_NAMESPACE, key, staged=True)
+        if data is None:
+            return None
+        return await _to_record(data, return_type, self._serializer)
+
+    async def get_descendants(self, execution_id: ExecutionId) -> list[ExecutionId]:
+        prefix = execution_id_to_path(execution_id) + "/"
+        keys = await self._client.list_keys(_EXECUTIONS_NAMESPACE, prefix, staged=True)
+        return [path_to_execution_id(k) for k in keys]
+
+    async def delete_executions(self, execution_ids: Iterable[ExecutionId]) -> None:
+        for execution_id in execution_ids:
+            key = execution_id_to_path(execution_id)
+            self._client.stage_delete(_EXECUTIONS_NAMESPACE, key)

glyff_sqlite/_transaction.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import asyncio
+import contextvars
+from typing import Any
+
+from glyff import Transaction
+
+
+class _ClientTransaction(Transaction):
+    def __init__(self, client: Any) -> None:
+        self._client = client
+        self._closed = False
+        self._lock = asyncio.Lock()
+        self._token: contextvars.Token | None = None
+        self._staging = None
+
+    async def begin(self) -> _ClientTransaction:
+        self._token, self._staging = self._client.begin_staging()
+        return self
+
+    async def commit(self) -> None:
+        async with self._lock:
+            if self._closed:
+                return
+
+            if self._staging is None:
+                raise RuntimeError("transaction not started")
+            self._client._require_current_staging(self._staging)
+            self._closed = True
+
+            try:
+                await self._client.commit_staged()
+            finally:
+                if self._token is None:
+                    raise RuntimeError("transaction not started")
+                self._client.end_staging(self._token)
+
+    async def rollback(self) -> None:
+        async with self._lock:
+            if self._closed:
+                return
+
+            if self._staging is None:
+                raise RuntimeError("transaction not started")
+            self._client._require_current_staging(self._staging)
+            self._closed = True
+
+            try:
+                await self._client.clear_staged()
+            finally:
+                if self._token is None:
+                    raise RuntimeError("transaction not started")
+                self._client.end_staging(self._token)

glyff_sqlite-0.12.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: glyff-sqlite
+Version: 0.12.0
+Summary: SQLite-backed durable SessionStore for glyff.
+License: MIT License
+        
+        Copyright (c) 2026 nueruyu
+        
+        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
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: glyff>=0.1.0
+Description-Content-Type: text/markdown
+
+# glyff-sqlite
+
+SQLite-backed durable `SessionStore` implementation for
+[glyff](https://pypi.org/project/glyff/).
+
+This is the **production** backend: one row per execution in a SQLite database,
+WAL mode, indexed lookups, and native transaction atomicity.
+
+## Install
+
+```bash
+pip install glyff-sqlite
+```
+
+This package depends on `glyff>=0.1.0` (no additional runtime dependencies —
+`sqlite3` is part of the standard library).
+
+## Usage
+
+```python
+from glyff.serialization import JsonSerializer
+from glyff_sqlite import SQLiteSessionStore
+
+store = SQLiteSessionStore("executions.sqlite3", JsonSerializer())
+```
+
+## Public API
+
+| Name                 | Description                                                   |
+| -------------------- | ------------------------------------------------------------- |
+| `SQLiteSessionStore` | Durable `SessionStore` backed by a local SQLite database.     |
+| `SQLiteClient`       | Low-level SQLite key/value store (generic, reusable).         |
+
+## External metadata
+
+The underlying ``SQLiteClient`` exposes ``stage_write`` / ``stage_delete`` /
+``stage_update`` so application code can persist its own rows alongside execution
+records and commit or roll back atomically together:
+
+```python
+client = SQLiteClient("session.sqlite3")
+store = SQLiteSessionStore(client=client, serializer=JsonSerializer())
+
+tx = await store.begin_transaction()
+execution = await store.start_execution(some_id)
+await execution.complete("ok", str)
+
+client.stage_write("metadata", "my_key", b"my_value")
+client.stage_delete("metadata", "old_key")
+
+await tx.commit()   # execution record + metadata commit atomically
+```
+
+## Transaction model
+
+- Writes are staged in-memory per transaction and flushed on commit.
+- Nested transactions (child scopes) commit independently of their parent.
+- `BEGIN IMMEDIATE` prevents writer contention; WAL mode keeps reads fast.
+- A per-database asyncio write lock serialises concurrent write transactions.
+
+## Status
+
+Early development. APIs may change before v1.0.
+
+## License
+
+MIT

glyff_sqlite-0.12.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+glyff_sqlite/__init__.py,sha256=xq2sTlXxFZu_kY_QUx7d-Lc1bTf-SdwPzLEt1yjMMfM,148
+glyff_sqlite/_sqlite_client.py,sha256=P1SYcCN2AfqERFG3tDLBuJ4J5GQiCdVpF91nuyrNUu4,11173
+glyff_sqlite/_sqlite_store.py,sha256=c2wyqupDMZqCMUc_XNO7AAxXyxLjGlF40gbZUsw_l9A,7672
+glyff_sqlite/_transaction.py,sha256=4iW6FT_UMipQSge7stfZlMkTBtlWLI2QL0aIWWKPB18,1660
+glyff_sqlite-0.12.0.dist-info/METADATA,sha256=VqFYs9EGExxT8a0C9tfDZg_KqEP_rATYuMGuCaQmQ9c,3899
+glyff_sqlite-0.12.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+glyff_sqlite-0.12.0.dist-info/licenses/LICENSE,sha256=bNtLcBZk03HGyB7qD0gK37uO4E0sre_G01X1vCFBPG8,1064
+glyff_sqlite-0.12.0.dist-info/RECORD,,

glyff_sqlite-0.12.0.dist-info/WHEEL

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

glyff_sqlite-0.12.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nueruyu
+
+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.