pl-key-value-sqlite-db 0.0.2__tar.gz → 0.0.4__tar.gz

{pl_key_value_sqlite_db-0.0.2 → pl_key_value_sqlite_db-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pl-key-value-sqlite-db
-Version: 0.0.2
+Version: 0.0.4
 Summary: A persistent key-value store on top of SQLite.
 Author: Peter Lavigne
 License-Expression: Apache-2.0
@@ -8,6 +8,8 @@ License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
 Requires-Dist: pl-run-program==0.0.30
 Requires-Dist: pl-mocks-and-fakes==0.0.30
+Requires-Dist: pl-user-io==0.0.17
+Requires-Dist: pl-tiny-clients==0.0.37
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: pydantic-settings>=2.13.1
 Requires-Python: >=3.12

{pl_key_value_sqlite_db-0.0.2 → pl_key_value_sqlite_db-0.0.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pl-key-value-sqlite-db"
-version = "0.0.2"
+version = "0.0.4"
 description = "A persistent key-value store on top of SQLite."
 readme = "README.md"
 authors = [{ name = "Peter Lavigne" }]
@@ -8,6 +8,8 @@ requires-python = ">=3.12"
 dependencies = [
     "pl-run-program==0.0.30",
     "pl-mocks-and-fakes==0.0.30",
+    "pl-user-io==0.0.17",
+    "pl-tiny-clients==0.0.37",
     "pydantic>=2.12.5",
     "pydantic-settings>=2.13.1",
 ]
@@ -55,7 +57,7 @@ extend-ignore = ["UP047"]
 typeCheckingMode = "strict"
 
 [tool.coverage.run]
-omit = ["tests/*", "src/pl_key_value_sqlite_db/testing/*"]
+omit = ["tests/*", "src/pl_key_value_sqlite_db/testing/*", "*_fake.py"]
 
 [tool.coverage.report]
 # Ignore all functions mocked in unit tests.

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/constants.py

@@ -0,0 +1,31 @@
+import pytest
+
+PYTEST_INTEGRATION_MARKER = pytest.mark.integration
+
+PYTEST_SLOW_MARKER = pytest.mark.slow
+PYTEST_NONDETERMINISTIC_MARKER = pytest.mark.nondeterministic
+PYTEST_DEPENDENT_MARKER = pytest.mark.dependent
+PYTEST_EXPENSIVE_MARKER = pytest.mark.expensive
+PYTEST_MANUAL_MARKER = pytest.mark.manual
+
+PYTEST_THIRD_PARTY_API_MARKERS = [
+    PYTEST_SLOW_MARKER,
+    PYTEST_NONDETERMINISTIC_MARKER,
+    PYTEST_DEPENDENT_MARKER,
+]
+
+PYTEST_MANUAL_MARKERS = [
+    PYTEST_SLOW_MARKER,
+    PYTEST_NONDETERMINISTIC_MARKER,
+    PYTEST_DEPENDENT_MARKER,
+    PYTEST_MANUAL_MARKER,
+]
+
+PYTEST_INTEGRATION_TEST_MARKERS = [
+    PYTEST_INTEGRATION_MARKER,
+    PYTEST_SLOW_MARKER,
+    PYTEST_NONDETERMINISTIC_MARKER,
+    PYTEST_DEPENDENT_MARKER,
+    PYTEST_EXPENSIVE_MARKER,
+    PYTEST_MANUAL_MARKER,
+]

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/create_key.py

@@ -0,0 +1,8 @@
+from pl_key_value_sqlite_db.create_key_value_key_unsafe import (
+    create_key_value_key_unsafe,
+)
+from pl_key_value_sqlite_db.key_types import BaseKey
+
+
+def create_key(key: BaseKey, value: str) -> None:
+    create_key_value_key_unsafe(key.value, value)

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/create_key_value_key_unsafe.py

@@ -0,0 +1,24 @@
+from pl_mocks_and_fakes import MockInUnitTests, MockReason
+
+from pl_key_value_sqlite_db.create_key_value_table_if_not_exists import (
+    KEY_COLUMN_NAME,
+    TABLE_NAME,
+    VALUE_COLUMN_NAME,
+)
+from pl_key_value_sqlite_db.execute_key_value_sql import execute_key_value_sql
+
+
+@MockInUnitTests(MockReason.UNINVESTIGATED)
+def create_key_value_key_unsafe(key: str, value: str) -> None:
+    """
+    Create a key in the database without type-safety.
+
+    You should probably use key_value.create_key instead.
+    """
+    sql = f"""
+        INSERT INTO {TABLE_NAME}
+        ({KEY_COLUMN_NAME}, {VALUE_COLUMN_NAME})
+        VALUES (?, ?)
+    """
+    with execute_key_value_sql(sql, (key, value)):
+        pass

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/create_key_value_table_if_not_exists.py

@@ -0,0 +1,21 @@
+from types import NoneType
+
+from pl_mocks_and_fakes import MockInUnitTests, MockReason
+
+from pl_key_value_sqlite_db.execute_key_value_sql import execute_key_value_sql
+
+TABLE_NAME = "key_value"
+KEY_COLUMN_NAME = "key"
+VALUE_COLUMN_NAME = "value"
+
+
+@MockInUnitTests(MockReason.UNINVESTIGATED)
+def create_key_value_table_if_not_exists() -> NoneType:
+    with execute_key_value_sql(f"""
+        CREATE TABLE IF NOT EXISTS {TABLE_NAME} (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            {KEY_COLUMN_NAME} TEXT NOT NULL UNIQUE,
+            {VALUE_COLUMN_NAME} TEXT NOT NULL
+        )
+    """):
+        pass

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/delete_key_value.py

@@ -0,0 +1,8 @@
+from pl_key_value_sqlite_db.delete_key_value_key_unsafe import (
+    delete_key_value_key_unsafe,
+)
+from pl_key_value_sqlite_db.key_types import BaseKey
+
+
+def delete_key_value(key: BaseKey) -> None:
+    delete_key_value_key_unsafe(key.value)

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/delete_key_value_key_unsafe.py

@@ -0,0 +1,14 @@
+from pl_mocks_and_fakes import MockInUnitTests, MockReason
+
+from pl_key_value_sqlite_db.create_key_value_table_if_not_exists import TABLE_NAME
+from pl_key_value_sqlite_db.execute_key_value_sql import execute_key_value_sql
+
+
+@MockInUnitTests(MockReason.UNINVESTIGATED)
+def delete_key_value_key_unsafe(key: str) -> None:
+    sql = f"""
+        DELETE FROM {TABLE_NAME}
+        WHERE key = ?
+    """
+    with execute_key_value_sql(sql, (key,)):
+        pass

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/execute_key_value_sql.py

@@ -0,0 +1,16 @@
+from collections.abc import Generator
+from contextlib import contextmanager
+
+from pl_mocks_and_fakes import MockInUnitTests, MockReason
+
+from pl_key_value_sqlite_db.execute_sql import ExecuteSqlResponse, execute_sql
+from pl_key_value_sqlite_db.settings import get_settings
+
+
+@MockInUnitTests(MockReason.UNINVESTIGATED)
+@contextmanager
+def execute_key_value_sql(
+    sql: str, params: tuple[str, ...] = ()
+) -> Generator[ExecuteSqlResponse]:
+    with execute_sql(sql, get_settings().key_value_db_path, params) as cursor:
+        yield cursor

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/execute_sql.py

@@ -0,0 +1,33 @@
+import logging
+import sqlite3
+from collections.abc import Callable, Generator
+from contextlib import contextmanager
+from typing import Any, NamedTuple
+
+from pl_mocks_and_fakes import MockInUnitTests, MockReason
+
+
+class ExecuteSqlResponse(NamedTuple):
+    fetch_one: Callable[[], tuple[Any, ...] | None]
+    fetch_all: Callable[[], list[tuple[Any, ...]]]
+
+
+@MockInUnitTests(MockReason.UNINVESTIGATED)
+@contextmanager
+def execute_sql(
+    sql: str, database_file_path: str, params: tuple[str, ...] = ()
+) -> Generator[ExecuteSqlResponse]:
+    conn = sqlite3.connect(
+        database_file_path
+    )  # Creates the DB file if it doesn't exist
+    cursor = conn.cursor()
+    logging.debug(f"Executing SQL:\n```\n{sql}\n```\nwith params: {params}")
+    try:
+        cursor.execute(sql, params)
+        yield ExecuteSqlResponse(
+            fetch_one=cursor.fetchone,
+            fetch_all=cursor.fetchall,
+        )
+        conn.commit()
+    finally:
+        conn.close()

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/get_all_key_value_keys.py

@@ -0,0 +1,18 @@
+import logging
+
+from pl_mocks_and_fakes import MockInUnitTests, MockReason
+
+from pl_key_value_sqlite_db.create_key_value_table_if_not_exists import TABLE_NAME
+from pl_key_value_sqlite_db.execute_key_value_sql import execute_key_value_sql
+
+
+@MockInUnitTests(MockReason.UNINVESTIGATED)
+def get_all_key_value_keys() -> list[str]:
+    sql = f"""
+        SELECT key
+        FROM {TABLE_NAME}
+    """
+    with execute_key_value_sql(sql) as cursor:
+        result = [row[0] for row in cursor.fetch_all()]
+        logging.debug(f"Returned value: {result}")
+        return result

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/key_types.py

@@ -0,0 +1,25 @@
+from enum import Enum
+
+
+class BaseKey(Enum):
+    pass
+
+
+class DateKey(BaseKey):
+    pass
+
+
+class BoolKey(BaseKey):
+    pass
+
+
+class DatetimeKey(BaseKey):
+    pass
+
+
+class StrKey(BaseKey):
+    pass
+
+
+class IntKey(BaseKey):
+    pass

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/key_value_migration.py

@@ -0,0 +1,32 @@
+import logging
+from pathlib import Path
+
+from pl_key_value_sqlite_db.create_key import create_key
+from pl_key_value_sqlite_db.create_key_value_table_if_not_exists import (
+    create_key_value_table_if_not_exists,
+)
+from pl_key_value_sqlite_db.delete_key_value_key_unsafe import (
+    delete_key_value_key_unsafe,
+)
+from pl_key_value_sqlite_db.get_all_key_value_keys import get_all_key_value_keys
+from pl_key_value_sqlite_db.key_types import BaseKey
+from pl_key_value_sqlite_db.settings import get_settings
+
+
+def run_migrations(initial_entries: dict[BaseKey, str]) -> None:
+    logging.info("Checking for migrations to run.")
+
+    if not Path(get_settings().key_value_db_path).exists():
+        create_key_value_table_if_not_exists()
+
+    existing_keys = get_all_key_value_keys()
+
+    for key, value in initial_entries.items():
+        if key.value not in existing_keys:
+            create_key(key, value)
+
+    for key in existing_keys:
+        if key not in [k.value for k in initial_entries]:
+            delete_key_value_key_unsafe(key)
+
+    logging.info("Finished running migrations.")

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/load_bool.py

@@ -0,0 +1,6 @@
+from pl_key_value_sqlite_db.key_types import BoolKey
+from pl_key_value_sqlite_db.load_value_untyped import load_value_untyped
+
+
+def load_bool(key: BoolKey) -> bool:
+    return load_value_untyped(key) == "True"

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/load_date.py

@@ -0,0 +1,8 @@
+from datetime import date
+
+from pl_key_value_sqlite_db.key_types import DateKey
+from pl_key_value_sqlite_db.load_value_untyped import load_value_untyped
+
+
+def load_date(key: DateKey) -> date:
+    return date.fromisoformat(load_value_untyped(key))

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/load_datetime.py

@@ -0,0 +1,8 @@
+from datetime import datetime
+
+from pl_key_value_sqlite_db.key_types import DatetimeKey
+from pl_key_value_sqlite_db.load_value_untyped import load_value_untyped
+
+
+def load_datetime(key: DatetimeKey) -> datetime:
+    return datetime.fromisoformat(load_value_untyped(key))

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/load_int.py

@@ -0,0 +1,6 @@
+from pl_key_value_sqlite_db.key_types import IntKey
+from pl_key_value_sqlite_db.load_value_untyped import load_value_untyped
+
+
+def load_int(key: IntKey) -> int:
+    return int(load_value_untyped(key))

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/load_key_value_unsafe.py

@@ -0,0 +1,26 @@
+import logging
+
+from pl_mocks_and_fakes import MockInUnitTests, MockReason
+
+from pl_key_value_sqlite_db.create_key_value_table_if_not_exists import TABLE_NAME
+from pl_key_value_sqlite_db.execute_key_value_sql import execute_key_value_sql
+
+
+@MockInUnitTests(MockReason.UNINVESTIGATED)
+def load_key_value_unsafe(key: str) -> str:
+    """
+    Get a value in the database by key without type-safety.
+
+    You should probably use key_value.get_value instead.
+    """
+    sql = f"""
+        SELECT value
+        FROM {TABLE_NAME}
+        WHERE key = ?
+    """
+    with execute_key_value_sql(sql, (key,)) as cursor:
+        result = cursor.fetch_one()
+        assert result is not None, f"Key '{key}' not found in database."
+        result_value = result[0]
+        logging.debug(f"Returned value: {result_value}")
+        return result_value

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/load_str.py

@@ -0,0 +1,6 @@
+from pl_key_value_sqlite_db.key_types import StrKey
+from pl_key_value_sqlite_db.load_value_untyped import load_value_untyped
+
+
+def load_str(key: StrKey) -> str:
+    return load_value_untyped(key)

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/load_value_untyped.py

@@ -0,0 +1,6 @@
+from pl_key_value_sqlite_db.key_types import BaseKey
+from pl_key_value_sqlite_db.load_key_value_unsafe import load_key_value_unsafe
+
+
+def load_value_untyped(key: BaseKey) -> str:
+    return load_key_value_unsafe(key.value)

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/save_bool.py

@@ -0,0 +1,6 @@
+from pl_key_value_sqlite_db.key_types import BoolKey
+from pl_key_value_sqlite_db.save_value_untyped import save_value_untyped
+
+
+def save_bool(key: BoolKey, value: bool) -> None:
+    save_value_untyped(key, str(value))

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/save_date.py

@@ -0,0 +1,11 @@
+from datetime import date
+
+from pl_key_value_sqlite_db.key_types import DateKey
+from pl_key_value_sqlite_db.save_value_untyped import save_value_untyped
+
+
+def save_date(key: DateKey, value: date) -> None:
+    if value.__class__.__name__ != "date":
+        msg = f"Expected date object, got {value.__class__.__name__}"
+        raise TypeError(msg)
+    save_value_untyped(key, value.isoformat())

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/save_datetime.py

@@ -0,0 +1,8 @@
+from datetime import datetime
+
+from pl_key_value_sqlite_db.key_types import DatetimeKey
+from pl_key_value_sqlite_db.save_value_untyped import save_value_untyped
+
+
+def save_datetime(key: DatetimeKey, value: datetime) -> None:
+    save_value_untyped(key, value.isoformat())

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/save_int.py

@@ -0,0 +1,6 @@
+from pl_key_value_sqlite_db.key_types import IntKey
+from pl_key_value_sqlite_db.save_value_untyped import save_value_untyped
+
+
+def save_int(key: IntKey, value: int) -> None:
+    save_value_untyped(key, str(value))

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/save_key_value_value_unsafe.py

@@ -0,0 +1,20 @@
+from pl_mocks_and_fakes import MockInUnitTests, MockReason
+
+from pl_key_value_sqlite_db.create_key_value_table_if_not_exists import TABLE_NAME
+from pl_key_value_sqlite_db.execute_key_value_sql import execute_key_value_sql
+
+
+@MockInUnitTests(MockReason.UNINVESTIGATED)
+def save_key_value_value_unsafe(key: str, value: str) -> None:
+    """
+    Set a value in the database by key without type-safety.
+
+    You should probably use key_value.set_value instead.
+    """
+    sql = f"""
+        UPDATE {TABLE_NAME}
+        SET value = ?
+        WHERE key = ?
+    """
+    with execute_key_value_sql(sql, (value, key)):
+        pass

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/save_str.py

@@ -0,0 +1,6 @@
+from pl_key_value_sqlite_db.key_types import StrKey
+from pl_key_value_sqlite_db.save_value_untyped import save_value_untyped
+
+
+def save_str(key: StrKey, value: str) -> None:
+    save_value_untyped(key, value)

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/save_value_untyped.py

@@ -0,0 +1,8 @@
+from pl_key_value_sqlite_db.key_types import BaseKey
+from pl_key_value_sqlite_db.save_key_value_value_unsafe import (
+    save_key_value_value_unsafe,
+)
+
+
+def save_value_untyped(key: BaseKey, value: str) -> None:
+    save_key_value_value_unsafe(key.value, value)

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/settings.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+
+from pl_mocks_and_fakes import MockInUnitTests, MockReason
+from pydantic import Field
+from pydantic_settings import (
+    BaseSettings,
+    SettingsConfigDict,
+)
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        extra="ignore",
+        secrets_dir=Path.home() / ".secrets-files",
+    )
+
+    # Env-specific config
+    key_value_db_path: str = Field(
+        validation_alias="KEY_VALUE_DB_PATH", default="~/bin/key_value.db"
+    )
+
+
+@MockInUnitTests(MockReason.UNMITIGATED_SIDE_EFFECT)
+def get_settings() -> Settings:
+    """Get settings. Raises exception if required settings are missing or invalid."""
+    # Required fields are populated from env/.env at runtime; pyright doesn't model that.
+    return Settings()  # pyright: ignore[reportCallIssue]

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/testing/__init__.py

@@ -0,0 +1 @@
+__all__ = []

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/testing/key_value_sqlite_fake.py

@@ -0,0 +1,49 @@
+from pl_mocks_and_fakes import Fake, mock_for
+
+from pl_key_value_sqlite_db.create_key_value_key_unsafe import (
+    create_key_value_key_unsafe,
+)
+from pl_key_value_sqlite_db.delete_key_value_key_unsafe import (
+    delete_key_value_key_unsafe,
+)
+from pl_key_value_sqlite_db.get_all_key_value_keys import get_all_key_value_keys
+from pl_key_value_sqlite_db.load_key_value_unsafe import load_key_value_unsafe
+from pl_key_value_sqlite_db.save_key_value_value_unsafe import (
+    save_key_value_value_unsafe,
+)
+
+
+class KeyValueSqliteFake(Fake):
+    def __init__(self) -> None:
+        def _get_all_keys_side_effect() -> list[str]:
+            return list(self.store.keys())
+
+        def _create_key_unsafe_side_effect(key: str, value: str) -> None:
+            if key not in self.store:
+                self.store[key] = value
+
+        def _delete_key_unsafe_side_effect(key: str) -> None:
+            del self.store[key]
+
+        def _load_value_unsafe_side_effect(key: str) -> str:
+            return self.store[key]
+
+        def _save_value_unsafe_side_effect(key: str, value: str) -> None:
+            if key not in self.store:
+                msg = f"Key `{key}` does not exist."
+                raise Exception(msg)
+            self.store[key] = value
+
+        self.store: dict[str, str] = {}
+
+        mock_for(get_all_key_value_keys).side_effect = _get_all_keys_side_effect
+        mock_for(
+            create_key_value_key_unsafe
+        ).side_effect = _create_key_unsafe_side_effect
+        mock_for(
+            delete_key_value_key_unsafe
+        ).side_effect = _delete_key_unsafe_side_effect
+        mock_for(load_key_value_unsafe).side_effect = _load_value_unsafe_side_effect
+        mock_for(
+            save_key_value_value_unsafe
+        ).side_effect = _save_value_unsafe_side_effect

pl_key_value_sqlite_db-0.0.4/src/pl_key_value_sqlite_db/testing/settings_fake.py

@@ -0,0 +1,12 @@
+from pl_mocks_and_fakes import Fake, stub
+
+from pl_key_value_sqlite_db.settings import Settings, get_settings
+
+
+class SettingsFake(Fake):
+    def __init__(self) -> None:
+        self.settings = Settings(
+            key_value_db_path="",
+        )
+        self.settings.key_value_db_path = ""
+        stub(get_settings)(self.settings)

pl_key_value_sqlite_db-0.0.2/src/pl_key_value_sqlite_db/placeholder.py

@@ -1,2 +0,0 @@
-def placeholder() -> None:
-    pass