ccflow-db 0.1.0__py3-none-any.whl

ccflow_db/__init__.py

@@ -0,0 +1,3 @@
+from .base import *
+
+__version__ = "0.1.0"

ccflow_db/base.py

@@ -0,0 +1,335 @@
+import json
+import re
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Type, Union
+
+from ccflow import BaseModel, CallableModel, ContextBase, ContextType, Flow, ResultBase, ResultType
+from ccflow_etl import CheckpointRecord, CheckpointStatus
+from pydantic import Field
+
+__all__ = (
+    "SQLiteConfig",
+    "SQLiteCacheStore",
+    "SQLiteCheckpointStore",
+    "SQLiteKeyExistsContext",
+    "SQLiteKeyExistsModel",
+    "SQLiteKeyExistsResult",
+    "SQLiteQueryContext",
+    "SQLiteQueryModel",
+    "SQLiteQueryResult",
+    "SQLiteTableWriteContext",
+    "SQLiteTableWriteModel",
+    "SQLiteTableWriteResult",
+)
+
+SQLiteTableWriteMode = Literal["append", "replace", "upsert"]
+SQLiteTableWriteStatus = Literal["written", "replaced", "upserted", "empty"]
+
+_IDENTIFIER_PATTERN = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+class SQLiteConfig(BaseModel):
+    path: Union[str, Path] = ":memory:"
+
+    def connect(self):
+        database_path = str(self.path)
+        if database_path != ":memory:":
+            Path(database_path).parent.mkdir(parents=True, exist_ok=True)
+        connection = sqlite3.connect(database_path)
+        connection.row_factory = sqlite3.Row
+        return connection
+
+
+class SQLiteCheckpointStore(BaseModel):
+    config: SQLiteConfig = Field(default_factory=SQLiteConfig)
+    table: str = "checkpoints"
+
+    def _ensure_table(self, connection: sqlite3.Connection) -> None:
+        connection.execute(
+            f"""
+            CREATE TABLE IF NOT EXISTS {_quote_identifier(self.table)} (
+                key TEXT PRIMARY KEY,
+                status TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                metadata TEXT NOT NULL
+            )
+            """
+        )
+
+    def get(self, key: str) -> Optional[CheckpointRecord]:
+        with self.config.connect() as connection:
+            self._ensure_table(connection)
+            row = connection.execute(
+                f"SELECT key, status, updated_at, metadata FROM {_quote_identifier(self.table)} WHERE key = ?", (key,)
+            ).fetchone()
+        if row is None:
+            return None
+        return CheckpointRecord(key=row["key"], status=row["status"], updated_at=row["updated_at"], metadata=json.loads(row["metadata"]))
+
+    def mark(self, key: str, status: CheckpointStatus, metadata: Optional[Dict[str, Any]] = None) -> CheckpointRecord:
+        record = CheckpointRecord(
+            key=key,
+            status=status,
+            updated_at=datetime.now(timezone.utc).isoformat(),
+            metadata=metadata or {},
+        )
+        with self.config.connect() as connection:
+            self._ensure_table(connection)
+            connection.execute(
+                f"""
+                INSERT INTO {_quote_identifier(self.table)} (key, status, updated_at, metadata)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(key) DO UPDATE SET
+                    status = excluded.status,
+                    updated_at = excluded.updated_at,
+                    metadata = excluded.metadata
+                """,
+                (record.key, record.status, record.updated_at, json.dumps(record.metadata, sort_keys=True)),
+            )
+        return record
+
+    def mark_succeeded(self, key: str, metadata: Optional[Dict[str, Any]] = None) -> CheckpointRecord:
+        return self.mark(key=key, status="succeeded", metadata=metadata)
+
+    def should_skip(self, key: str) -> bool:
+        record = self.get(key)
+        return record is not None and record.status == "succeeded"
+
+
+class SQLiteCacheStore(BaseModel):
+    config: SQLiteConfig = Field(default_factory=SQLiteConfig)
+    table: str = "cache_entries"
+
+    def _ensure_table(self, connection: sqlite3.Connection) -> None:
+        connection.execute(
+            f"""
+            CREATE TABLE IF NOT EXISTS {_quote_identifier(self.table)} (
+                key TEXT PRIMARY KEY,
+                payload BLOB NOT NULL,
+                content_type TEXT,
+                updated_at TEXT NOT NULL
+            )
+            """
+        )
+
+    def uri(self, key: str) -> str:
+        return f"sqlite://{self.config.path}/{self.table}/{key}"
+
+    def exists(self, key: str) -> bool:
+        with self.config.connect() as connection:
+            self._ensure_table(connection)
+            row = connection.execute(f"SELECT 1 FROM {_quote_identifier(self.table)} WHERE key = ? LIMIT 1", (key,)).fetchone()
+        return row is not None
+
+    def put_bytes(self, key: str, value: bytes, content_type: Optional[str] = None) -> Dict[str, Any]:
+        with self.config.connect() as connection:
+            self._ensure_table(connection)
+            connection.execute(
+                f"""
+                INSERT INTO {_quote_identifier(self.table)} (key, payload, content_type, updated_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(key) DO UPDATE SET
+                    payload = excluded.payload,
+                    content_type = excluded.content_type,
+                    updated_at = excluded.updated_at
+                """,
+                (key, sqlite3.Binary(value), content_type, datetime.now(timezone.utc).isoformat()),
+            )
+        return {"table": self.table, "key": key}
+
+    def get_bytes(self, key: str) -> bytes:
+        with self.config.connect() as connection:
+            self._ensure_table(connection)
+            row = connection.execute(f"SELECT payload FROM {_quote_identifier(self.table)} WHERE key = ? LIMIT 1", (key,)).fetchone()
+        if row is None:
+            raise FileNotFoundError(self.uri(key))
+        return bytes(row["payload"])
+
+
+class SQLiteQueryContext(ContextBase):
+    sql: str
+    params: Union[List[Any], Dict[str, Any]] = Field(default_factory=list)
+    fetch: bool = False
+
+
+class SQLiteQueryResult(ResultBase):
+    rows: List[Dict[str, Any]] = Field(default_factory=list)
+    rowcount: int
+
+
+class SQLiteKeyExistsContext(ContextBase):
+    table: str
+    key: Dict[str, Any] = Field(default_factory=dict)
+
+
+class SQLiteKeyExistsResult(ResultBase):
+    table: str
+    key: Dict[str, Any] = Field(default_factory=dict)
+    exists: bool
+
+
+class SQLiteQueryModel(CallableModel):
+    config: SQLiteConfig = Field(default_factory=SQLiteConfig)
+
+    @property
+    def context_type(self) -> Type[ContextType]:
+        return SQLiteQueryContext
+
+    @property
+    def result_type(self) -> Type[ResultType]:
+        return SQLiteQueryResult
+
+    @Flow.call
+    def __call__(self, context: SQLiteQueryContext) -> SQLiteQueryResult:
+        with self.config.connect() as connection:
+            cursor = connection.execute(context.sql, context.params)
+            rows = [dict(row) for row in cursor.fetchall()] if context.fetch else []
+            return SQLiteQueryResult(rows=rows, rowcount=cursor.rowcount)
+
+
+class SQLiteTableWriteContext(ContextBase):
+    table: str
+    rows: List[Dict[str, Any]] = Field(default_factory=list)
+    mode: SQLiteTableWriteMode = "append"
+    primary_key: List[str] = Field(default_factory=list)
+
+
+class SQLiteTableWriteResult(ResultBase):
+    table: str
+    status: SQLiteTableWriteStatus
+    rows_written: int
+    columns: List[str] = Field(default_factory=list)
+
+
+def _quote_identifier(identifier: str) -> str:
+    if not _IDENTIFIER_PATTERN.fullmatch(identifier):
+        raise ValueError(f"Invalid SQLite identifier: {identifier!r}")
+    return f'"{identifier}"'
+
+
+def _columns(rows: List[Dict[str, Any]]) -> List[str]:
+    columns = []
+    for row in rows:
+        for column in row:
+            if column not in columns:
+                columns.append(column)
+    return columns
+
+
+def _sqlite_type(values: List[Any]) -> str:
+    for value in values:
+        if value is None:
+            continue
+        if isinstance(value, bool):
+            return "INTEGER"
+        if isinstance(value, int):
+            return "INTEGER"
+        if isinstance(value, float):
+            return "REAL"
+        if isinstance(value, bytes):
+            return "BLOB"
+        return "TEXT"
+    return "TEXT"
+
+
+def _column_types(rows: List[Dict[str, Any]], columns: List[str]) -> Dict[str, str]:
+    return {column: _sqlite_type([row.get(column) for row in rows]) for column in columns}
+
+
+def _sqlite_value(value: Any) -> Any:
+    if isinstance(value, bool):
+        return int(value)
+    if isinstance(value, (dict, list)):
+        return json.dumps(value, sort_keys=True)
+    return value
+
+
+def _table_exists(connection: sqlite3.Connection, table: str) -> bool:
+    row = connection.execute("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?", (table,)).fetchone()
+    return row is not None
+
+
+def _create_table_sql(table: str, columns: List[str], column_types: Dict[str, str], primary_key: List[str]) -> str:
+    column_sql = [f"{_quote_identifier(column)} {column_types[column]}" for column in columns]
+    if primary_key:
+        missing_keys = [column for column in primary_key if column not in columns]
+        if missing_keys:
+            raise ValueError(f"Primary key columns are missing from rows: {missing_keys}")
+        column_sql.append(f"PRIMARY KEY ({', '.join(_quote_identifier(column) for column in primary_key)})")
+    return f"CREATE TABLE IF NOT EXISTS {_quote_identifier(table)} ({', '.join(column_sql)})"
+
+
+def _insert_sql(table: str, columns: List[str], mode: SQLiteTableWriteMode, primary_key: List[str]) -> str:
+    quoted_columns = [_quote_identifier(column) for column in columns]
+    placeholders = ", ".join("?" for _column in columns)
+    sql = f"INSERT INTO {_quote_identifier(table)} ({', '.join(quoted_columns)}) VALUES ({placeholders})"
+    if mode != "upsert":
+        return sql
+    if not primary_key:
+        raise ValueError("SQLite upsert mode requires primary_key.")
+
+    update_columns = [column for column in columns if column not in primary_key]
+    if not update_columns:
+        return f"{sql} ON CONFLICT({', '.join(_quote_identifier(column) for column in primary_key)}) DO NOTHING"
+    assignments = ", ".join(f"{_quote_identifier(column)} = excluded.{_quote_identifier(column)}" for column in update_columns)
+    return f"{sql} ON CONFLICT({', '.join(_quote_identifier(column) for column in primary_key)}) DO UPDATE SET {assignments}"
+
+
+class SQLiteTableWriteModel(CallableModel):
+    config: SQLiteConfig = Field(default_factory=SQLiteConfig)
+
+    @property
+    def context_type(self) -> Type[ContextType]:
+        return SQLiteTableWriteContext
+
+    @property
+    def result_type(self) -> Type[ResultType]:
+        return SQLiteTableWriteResult
+
+    @Flow.call
+    def __call__(self, context: SQLiteTableWriteContext) -> SQLiteTableWriteResult:
+        if not context.rows:
+            return SQLiteTableWriteResult(table=context.table, status="empty", rows_written=0, columns=[])
+
+        columns = _columns(context.rows)
+        values = [[_sqlite_value(row.get(column)) for column in columns] for row in context.rows]
+        column_types = _column_types(context.rows, columns)
+
+        with self.config.connect() as connection:
+            if context.mode == "replace":
+                connection.execute(f"DROP TABLE IF EXISTS {_quote_identifier(context.table)}")
+            connection.execute(_create_table_sql(context.table, columns, column_types, context.primary_key))
+            connection.executemany(_insert_sql(context.table, columns, context.mode, context.primary_key), values)
+
+        status: SQLiteTableWriteStatus = {"append": "written", "replace": "replaced", "upsert": "upserted"}[context.mode]
+        return SQLiteTableWriteResult(table=context.table, status=status, rows_written=len(context.rows), columns=columns)
+
+
+class SQLiteKeyExistsModel(CallableModel):
+    config: SQLiteConfig = Field(default_factory=SQLiteConfig)
+
+    @property
+    def context_type(self) -> Type[ContextType]:
+        return SQLiteKeyExistsContext
+
+    @property
+    def result_type(self) -> Type[ResultType]:
+        return SQLiteKeyExistsResult
+
+    @Flow.call
+    def __call__(self, context: SQLiteKeyExistsContext) -> SQLiteKeyExistsResult:
+        if not context.key:
+            raise ValueError("SQLite key existence checks require at least one key column.")
+
+        table = _quote_identifier(context.table)
+        columns = list(context.key)
+        where_clause = " AND ".join(f"{_quote_identifier(column)} = ?" for column in columns)
+        values = [_sqlite_value(context.key[column]) for column in columns]
+
+        with self.config.connect() as connection:
+            if not _table_exists(connection, context.table):
+                return SQLiteKeyExistsResult(table=context.table, key=context.key, exists=False)
+            row = connection.execute(f"SELECT 1 FROM {table} WHERE {where_clause} LIMIT 1", values).fetchone()
+        return SQLiteKeyExistsResult(table=context.table, key=context.key, exists=row is not None)

ccflow_db/config/cache/sqlite.yaml

@@ -0,0 +1,18 @@
+# @package cache
+
+store:
+  _target_: ccflow_db.SQLiteCacheStore
+  config:
+    _target_: ccflow_db.SQLiteConfig
+    path: ccflow-cache.sqlite
+  table: cache_entries
+
+put:
+  _target_: ccflow_etl.CachePutModel
+  store: /cache/store
+  format: json
+
+get:
+  _target_: ccflow_etl.CacheGetModel
+  store: /cache/store
+  format: json

ccflow_db/config/checkpoint/sqlite.yaml

@@ -0,0 +1,8 @@
+# @package checkpoint
+
+store:
+  _target_: ccflow_db.SQLiteCheckpointStore
+  config:
+    _target_: ccflow_db.SQLiteConfig
+    path: ccflow-checkpoints.sqlite
+  table: checkpoints

ccflow_db/tests/test_all.py

@@ -0,0 +1,5 @@
+from ccflow_db import *  # noqa
+
+
+def test_all():
+    assert True

ccflow_db/tests/test_sqlite.py

@@ -0,0 +1,191 @@
+from pathlib import Path
+
+import pytest
+import tomllib
+from ccflow_etl import CacheGetContext, CacheGetModel, CachePutContext, CachePutModel, ETLArtifact
+from hydra import compose, initialize_config_dir
+from hydra.utils import instantiate
+
+from ccflow_db import (
+    SQLiteCacheStore,
+    SQLiteCheckpointStore,
+    SQLiteConfig,
+    SQLiteKeyExistsContext,
+    SQLiteKeyExistsModel,
+    SQLiteQueryContext,
+    SQLiteQueryModel,
+    SQLiteTableWriteContext,
+    SQLiteTableWriteModel,
+)
+
+
+def test_sqlite_config_package_is_exposed_for_hydra_lerna_plugins(tmp_path):
+    pyproject = tomllib.loads((Path(__file__).parents[2] / "pyproject.toml").read_text())
+    assert pyproject["project"]["entry-points"]["hydra.lernaplugins"]["ccflow-db"] == "pkg:ccflow_db.config"
+
+    (tmp_path / "runner.yaml").write_text(
+        """
+defaults:
+  - _self_
+  - cache: sqlite
+  - checkpoint: sqlite
+
+hydra:
+  searchpath:
+    - pkg://ccflow_db.config
+""".lstrip()
+    )
+
+    with initialize_config_dir(config_dir=str(tmp_path), version_base=None):
+        cfg = compose(config_name="runner")
+
+    assert isinstance(instantiate(cfg.cache.store), SQLiteCacheStore)
+    assert isinstance(instantiate(cfg.checkpoint.store), SQLiteCheckpointStore)
+
+
+def test_sqlite_table_write_appends_and_queries_rows(tmp_path):
+    config = SQLiteConfig(path=tmp_path / "market.sqlite")
+
+    write_result = SQLiteTableWriteModel(config=config)(
+        SQLiteTableWriteContext(
+            table="daily_bars",
+            rows=[
+                {"ticker": "AAA", "date": "2024-01-03", "close": 103.6, "volume": 12345},
+                {"ticker": "BBB", "date": "2024-01-03", "close": 27.5, "volume": 45678},
+            ],
+        )
+    )
+    rows = SQLiteQueryModel(config=config)(
+        SQLiteQueryContext(sql="SELECT ticker, date, close, volume FROM daily_bars WHERE ticker = ?", params=["AAA"], fetch=True)
+    ).rows
+
+    assert write_result.table == "daily_bars"
+    assert write_result.status == "written"
+    assert write_result.rows_written == 2
+    assert rows == [{"ticker": "AAA", "date": "2024-01-03", "close": 103.6, "volume": 12345}]
+
+
+def test_sqlite_table_write_replaces_and_upserts_rows(tmp_path):
+    config = SQLiteConfig(path=tmp_path / "market.sqlite")
+    writer = SQLiteTableWriteModel(config=config)
+    reader = SQLiteQueryModel(config=config)
+
+    writer(
+        SQLiteTableWriteContext(
+            table="daily_bars",
+            rows=[{"ticker": "AAA", "date": "2024-01-03", "close": 103.6}],
+            primary_key=["ticker", "date"],
+        )
+    )
+    replace_result = writer(
+        SQLiteTableWriteContext(
+            table="daily_bars",
+            rows=[{"ticker": "BBB", "date": "2024-01-03", "close": 27.5}],
+            mode="replace",
+            primary_key=["ticker", "date"],
+        )
+    )
+    upsert_result = writer(
+        SQLiteTableWriteContext(
+            table="daily_bars",
+            rows=[
+                {"ticker": "BBB", "date": "2024-01-03", "close": 28.0},
+                {"ticker": "CCC", "date": "2024-01-03", "close": 11.0},
+            ],
+            mode="upsert",
+            primary_key=["ticker", "date"],
+        )
+    )
+    rows = reader(SQLiteQueryContext(sql="SELECT ticker, close FROM daily_bars ORDER BY ticker", fetch=True)).rows
+
+    assert replace_result.status == "replaced"
+    assert upsert_result.status == "upserted"
+    assert rows == [{"ticker": "BBB", "close": 28.0}, {"ticker": "CCC", "close": 11.0}]
+
+
+def test_sqlite_key_exists_checks_rows_by_key(tmp_path):
+    config = SQLiteConfig(path=tmp_path / "market.sqlite")
+    SQLiteTableWriteModel(config=config)(
+        SQLiteTableWriteContext(
+            table="daily_bars",
+            rows=[{"ticker": "AAA", "date": "2024-01-03", "close": 103.6}],
+            primary_key=["ticker", "date"],
+        )
+    )
+    exists_model = SQLiteKeyExistsModel(config=config)
+
+    existing = exists_model(SQLiteKeyExistsContext(table="daily_bars", key={"ticker": "AAA", "date": "2024-01-03"}))
+    missing = exists_model(SQLiteKeyExistsContext(table="daily_bars", key={"ticker": "BBB", "date": "2024-01-03"}))
+    missing_table = exists_model(SQLiteKeyExistsContext(table="other_daily_bars", key={"ticker": "AAA", "date": "2024-01-03"}))
+
+    assert existing.exists is True
+    assert existing.table == "daily_bars"
+    assert existing.key == {"ticker": "AAA", "date": "2024-01-03"}
+    assert missing.exists is False
+    assert missing_table.exists is False
+
+
+def test_sqlite_table_write_rolls_back_transaction_on_insert_failure(tmp_path):
+    config = SQLiteConfig(path=tmp_path / "market.sqlite")
+    writer = SQLiteTableWriteModel(config=config)
+    reader = SQLiteQueryModel(config=config)
+
+    writer(
+        SQLiteTableWriteContext(
+            table="daily_bars",
+            rows=[{"ticker": "AAA", "date": "2024-01-03", "close": 103.6}],
+            primary_key=["ticker", "date"],
+        )
+    )
+
+    with pytest.raises(Exception):
+        writer(
+            SQLiteTableWriteContext(
+                table="daily_bars",
+                rows=[
+                    {"ticker": "BBB", "date": "2024-01-03", "close": 27.5},
+                    {"ticker": "AAA", "date": "2024-01-03", "close": 104.0},
+                ],
+            )
+        )
+
+    rows = reader(SQLiteQueryContext(sql="SELECT ticker, close FROM daily_bars ORDER BY ticker", fetch=True)).rows
+
+    assert rows == [{"ticker": "AAA", "close": 103.6}]
+
+
+def test_sqlite_checkpoint_store_marks_and_reads_completed_units(tmp_path):
+    store = SQLiteCheckpointStore(config=SQLiteConfig(path=tmp_path / "checkpoints.sqlite"))
+
+    store.mark_succeeded("massive:daily:AAA:2024-01-03", metadata={"path": "daily/AAA/2024-01-03.json"})
+
+    record = store.get("massive:daily:AAA:2024-01-03")
+    assert record is not None
+    assert record.key == "massive:daily:AAA:2024-01-03"
+    assert record.status == "succeeded"
+    assert record.metadata == {"path": "daily/AAA/2024-01-03.json"}
+    assert store.should_skip("massive:daily:AAA:2024-01-03") is True
+    assert store.should_skip("massive:daily:AAA:2024-01-04") is False
+
+
+def test_sqlite_cache_put_and_get_exposes_typed_artifacts(tmp_path):
+    store = SQLiteCacheStore(config=SQLiteConfig(path=tmp_path / "cache.sqlite"), table="cache_entries")
+
+    put_model = CachePutModel(store=store, format="json")
+    get_model = CacheGetModel(store=store, format="json")
+    put_result = put_model(CachePutContext(key="massive/stocks/normalized/2024-01-03/AAA", payload={"ticker": "AAA"}, dataset="stocks", stage="load"))
+    second_put = put_model(CachePutContext(key="massive/stocks/normalized/2024-01-03/AAA", payload={"ticker": "BBB"}, dataset="stocks", stage="load"))
+    get_result = get_model(CacheGetContext(key="massive/stocks/normalized/2024-01-03/AAA", dataset="stocks", stage="load"))
+
+    assert put_result.status == "written"
+    assert second_put.status == "exists"
+    assert get_result.status == "hit"
+    assert get_result.payload == {"ticker": "AAA"}
+    assert put_result.artifact == ETLArtifact(
+        key="massive/stocks/normalized/2024-01-03/AAA",
+        dataset="stocks",
+        stage="load",
+        uri=f"sqlite://{tmp_path / 'cache.sqlite'}/cache_entries/massive/stocks/normalized/2024-01-03/AAA.json",
+        media_type="application/json",
+        status="written",
+    )

ccflow_db-0.1.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: ccflow-db
+Version: 0.1.0
+Summary: ccflow models for database access
+Project-URL: Repository, https://github.com/1kbgz/ccflow-db
+Project-URL: Homepage, https://github.com/1kbgz/ccflow-db
+Author-email: 1kbgz <dev@1kbgz.com>
+License: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Requires-Dist: ccflow-etl>=0.1.1
+Requires-Dist: ccflow>=0.6.10
+Provides-Extra: develop
+Requires-Dist: build; extra == 'develop'
+Requires-Dist: bump-my-version; extra == 'develop'
+Requires-Dist: check-dist; extra == 'develop'
+Requires-Dist: codespell; extra == 'develop'
+Requires-Dist: hatchling; extra == 'develop'
+Requires-Dist: mdformat; extra == 'develop'
+Requires-Dist: mdformat-tables>=1; extra == 'develop'
+Requires-Dist: pytest; extra == 'develop'
+Requires-Dist: pytest-cov; extra == 'develop'
+Requires-Dist: ruff; extra == 'develop'
+Requires-Dist: twine; extra == 'develop'
+Requires-Dist: ty; extra == 'develop'
+Requires-Dist: uv; extra == 'develop'
+Requires-Dist: wheel; extra == 'develop'
+Description-Content-Type: text/markdown
+
+# ccflow-db
+
+ccflow models for database access
+
+[![Build Status](https://github.com/1kbgz/ccflow-db/actions/workflows/build.yaml/badge.svg?branch=main&event=push)](https://github.com/1kbgz/ccflow-db/actions/workflows/build.yaml)
+[![codecov](https://codecov.io/gh/1kbgz/ccflow-db/branch/main/graph/badge.svg)](https://codecov.io/gh/1kbgz/ccflow-db)
+[![License](https://img.shields.io/github/license/1kbgz/ccflow-db)](https://github.com/1kbgz/ccflow-db)
+[![PyPI](https://img.shields.io/pypi/v/ccflow-db.svg)](https://pypi.python.org/pypi/ccflow-db)
+
+## Overview
+
+`ccflow-db` provides public, domain-neutral database callable models and publishers for `ccflow` workflows. It owns connection configuration, SQL execution, tabular reads, bulk writes, transaction handling, upsert/merge patterns, database-backed checkpoint/cache adapters, and Hydra config groups exposed through the lerna plugin entry point.
+
+It should stay generic across domains and database backends. Domain schemas, provider-specific assumptions, and application deployment conventions belong outside this package.
+
+## Current Status
+
+- Implemented: package scaffold, version metadata, `SQLiteConfig`, parameterized `SQLiteQueryModel`, `SQLiteKeyExistsModel`, `SQLiteTableWriteModel` for append, replace, and primary-key upsert writes, `SQLiteCheckpointStore`, byte-oriented `SQLiteCacheStore` for use with `ccflow-etl` cache format models, and `cache=sqlite` / `checkpoint=sqlite` config groups.
+- Partial: SQLite uses the Python standard library as the first local backend; broad SQLAlchemy-style engine/session management and backend extras remain future work.
+- Missing: dataframe reads, chunked writes, dry-run SQL rendering, merge helpers beyond SQLite upsert, and non-SQLite integration tests.
+
+## Dependency Contract
+
+- Depends on `ccflow` for callable model and publisher interfaces.
+- Depends on `ccflow-etl` for generic checkpoint records and cache format/result contracts.
+- Uses `sqlite3` for the first local backend and may add a broader abstraction layer such as SQLAlchemy plus optional backend extras later.
+- Must not depend on finance packages or application-specific packages.
+
+## Test Convention
+
+Default tests should use SQLite or in-memory database fixtures. Backend-specific tests such as Postgres should be opt-in and skipped unless the required environment variables are set.
+
+> [!NOTE]
+> This library was generated using [copier](https://copier.readthedocs.io/en/stable/) from the [Base Python Project Template repository](https://github.com/python-project-templates/base).

ccflow_db-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+ccflow_db/__init__.py,sha256=GZa5kRIfRkSwASZsKw2rf3LPXqLZmmppxKbLjKZC2UU,43
+ccflow_db/base.py,sha256=gglYQGykjHiC1-5qLbpoi5EV5_0WoRATxqTZIpz6-6o,12858
+ccflow_db/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ccflow_db/config/cache/sqlite.yaml,sha256=buMkmKwD4_TRM56TsmNFq9_qErqFNLl0hqe43WaYw2s,323
+ccflow_db/config/checkpoint/sqlite.yaml,sha256=snYbmQmCLzn6XHAFUM1-z7d9mXguM58ZRkyqG6rQ-pQ,177
+ccflow_db/tests/test_all.py,sha256=iCzfjXrdAk6iHKfgQ0x8-YY_s6tYD7N101GWRZpo5Ng,66
+ccflow_db/tests/test_sqlite.py,sha256=G8p7CYSMLkv2PA9WPm1vHUMgXFFdAxZ-JCk_b0lhsuQ,7322
+ccflow_db-0.1.0.dist-info/METADATA,sha256=5Td-Ulai4Fx9X6CghOlM_2HUhREppBnKD612aIrF0wk,4154
+ccflow_db-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+ccflow_db-0.1.0.dist-info/entry_points.txt,sha256=-54XfntLasAimLUU9mDiwq1Tt7FgLYP9LTDhXLKqtk4,54
+ccflow_db-0.1.0.dist-info/licenses/LICENSE,sha256=RcPqVYf2JyhlV4FlBQud0104R3fT1_-7XbT-vp4eLyE,11335
+ccflow_db-0.1.0.dist-info/RECORD,,

ccflow_db-0.1.0.dist-info/WHEEL

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

ccflow_db-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[hydra.lernaplugins]
+ccflow-db = pkg:ccflow_db.config

ccflow_db-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 1kbgz
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.