diskstore 0.1.0__py3-none-any.whl

diskstore/__init__.py

@@ -0,0 +1,4 @@
+from .const import DEFAULT_PRAGMAS, TIMEOUT, AnyLite, KeyType  # noqa
+from .diskread import DiskRead, Value  # noqa
+from .diskstore import DiskStore  # noqa
+from .diskcache import DiskCache  # noqa

diskstore/const.py

@@ -0,0 +1,25 @@
+"""Core disktore API."""
+
+from typing import (
+    TypeAlias,
+    Union,
+)
+
+TIMEOUT = 60.0  # in seconds
+
+MISSING = object()
+
+
+DEFAULT_PRAGMAS = {
+    "auto_vacuum": 0,  # 1=FULL, 0=None
+    "cache_size": 2**13,  # 8,192 pages
+    "journal_mode": "wal",
+    "mmap_size": 2**28,  # 256 MB
+    "synchronous": 1,  # 0=OFF, 1=NORMAL, 2=FULL, 3=EXTRA
+    "temp_store": "memory",
+    # "pargma_busy_timeout": 5000,  # milliseconds
+}
+
+
+AnyLite: TypeAlias = Union[bytes, str, int, float]
+KeyType = AnyLite

diskstore/diskcache.py

@@ -0,0 +1,136 @@
+"""Core disktore API."""
+
+import os
+import os.path
+import pickle
+from time import time
+from typing import (
+    NamedTuple,
+)
+
+from .const import MISSING, TIMEOUT, KeyType
+from .diskstore import DiskStore
+
+
+class CacheValue(NamedTuple):
+    value: bytes
+    expires_at: float
+
+    def load(self, expire_timestamp, default=MISSING):
+        expires_at = self[1]
+        if expires_at == 0.0 or expires_at > time():
+            return pickle.loads(self[0])
+        return default
+
+    @classmethod
+    def create(cls, value, expires=None):
+        expires_at = 0.0
+        if expires:
+            expires_at = time() + expires
+        return cls(value=pickle.dumps(value), expires_at=expires_at)
+
+
+class DiskCache:
+    def __init__(
+        self,
+        filename: os.PathLike | str,
+        default_expiration=60.0,
+    ) -> None:
+        """Initialize DiskCache instance.
+
+        :param str filename: DiskStore DB filename.
+                              If not set a tmp directory and default DB name is created.
+        :param float default_expiration: Default expiration value in seconds (float)
+        """
+        self._diskstore = DiskStore(
+            filename=filename,
+            value_class=CacheValue,
+            tablename="Cache",
+            timeout=TIMEOUT,
+            pragma_auto_vacuum=1,
+            pragma_synchronous=0,
+            alter_table=False,
+        )
+        self._default_expiration = default_expiration
+
+    def delete(self, key: KeyType) -> bool:
+        bin_key = pickle.dumps(key)
+        try:
+            del self._diskstore[bin_key]
+            return True
+        except KeyError:
+            return False
+
+    def set(self, key, value, expire=None):
+        bin_key = pickle.dumps(key)
+        if expire is None:
+            expire = self._default_expiration
+        v = CacheValue.create(value, expire)
+        self._diskstore[bin_key] = v
+
+    def get(
+        self,
+        key: KeyType,
+        default=None,
+    ):
+        bin_key = pickle.dumps(key)
+        try:
+            result = self._diskstore[bin_key]
+        except KeyError:
+            return default
+
+        return result.load(expire_timestamp=time(), default=default)
+
+    def add(self, key, value, expire=None):
+        bin_key = pickle.dumps(key)
+        v = CacheValue.create(value, expire)
+        ret_key = self._diskstore.add(bin_key, v)
+        if ret_key is None:
+            return False
+
+        return True
+
+    def delete_expired(self):
+        delete_expired = "DELETE FROM Cache WHERE expires_at != 0.0 AND expires_at < ?"
+        with self._diskstore.transact() as cx:
+            cx.execute(delete_expired, (time(),))
+
+    def touch(self, key, expire=None):
+        bin_key = pickle.dumps(key)
+        if expire is None:
+            expire = self._default_expiration
+        expires_at = time() + expire if expire else 0.0
+        stmt = "UPDATE Cache SET expires_at = ? WHERE _key = ?"
+        with self._diskstore.transact() as cx:
+            cx.execute(stmt, (expires_at, bin_key))
+
+    @property
+    def filename(self):
+        return self._diskstore.filename
+
+    def check(self, *args, **kwargs):
+        return self._diskstore.check(*args, **kwargs)
+
+    def clear(self):
+        self._diskstore.clear()
+
+    def close(self):
+        self._diskstore.close()
+
+    def __enter__(self):
+        self._diskstore.__enter__()
+        return self
+
+    def __exit__(self, *args, **kwargs) -> None:
+        self._diskstore.__exit__(*args, **kwargs)
+
+    def __len__(self):
+        return len(self._diskstore)
+
+    def __iter__(self):
+        for key in self._diskstore:
+            yield pickle.loads(key)
+
+    def __reversed__(self):
+        for key in reversed(self._diskstore):
+            yield pickle.loads(key)

diskstore/diskread.py

@@ -0,0 +1,272 @@
+"""DiskRead (Mapping) API."""
+
+import os
+import os.path
+import threading
+from collections.abc import ItemsView, KeysView, Mapping, ValuesView
+from contextlib import closing, contextmanager
+from typing import Generator, NamedTuple, Optional, Sequence, TypeAlias, Union
+
+import apsw
+
+from .const import MISSING, TIMEOUT, KeyType
+
+Connection = apsw.Connection
+Cursor = apsw.Cursor
+
+
+BasicType: TypeAlias = Union[bytes, str, int, float]
+
+
+class Value(NamedTuple):
+    value: BasicType
+
+    def __float__(self):
+        data = self[0]
+        if isinstance(data, float):
+            return data
+        raise ValueError("Internal value is not an instance of float.")
+
+    def __int__(self):
+        data = self[0]
+        if isinstance(data, int):
+            return data
+        raise ValueError("Internal value is not an instance of int.")
+
+    def __bytes__(self):
+        data = self[0]
+        if isinstance(data, bytes):
+            return data
+        raise ValueError("Internal value is not an instance of bytes.")
+
+    def __str__(self):
+        return str(self[0])
+
+
+class DiskKeysView(KeysView):
+    __slots__ = ()
+
+    def __iter__(self):
+        return iter(self._mapping)  # ty:ignore[unresolved-attribute]
+
+    def __reversed__(self):
+        return reversed(self._mapping)  # ty:ignore[unresolved-attribute]
+
+
+class DiskValuesView(ValuesView):
+    __slots__ = ()
+
+    def __iter__(self):
+        for _, value in self._mapping.query(order="rowid ASC"):  # ty:ignore[unresolved-attribute]
+            yield value
+
+    def __reversed__(self):
+        for _, value in self._mapping.query(order="rowid DESC"):  # ty:ignore[unresolved-attribute]
+            yield value
+
+
+class DiskItemsView(ItemsView):
+    __slots__ = ()
+
+    def __iter__(self):
+        return self._mapping.query(order="rowid ASC")  # ty:ignore[unresolved-attribute]
+
+    def __reversed__(self):
+        return self._mapping.query(order="rowid DESC")  # ty:ignore[unresolved-attribute]
+
+
+class DiskRead(Mapping):
+    """SQLite read only disk storage. Does not connect on init!"""
+
+    def __init__(  # noqa: PLR0915
+        self,
+        filename: os.PathLike | str,
+        value_class=None,
+        tablename: str | None = None,
+        timeout=None,
+    ) -> None:
+        """Initialize cache instance.
+
+        :param str filename: filename for DB to use.
+        :param str tablename: Optional table name to use.
+        :param type value_class: Class type (inherited from NamedTuple)
+                                 used to get back data.
+        :param float timeout: SQLite connection timeout
+                              (also used if DB is busy to retry)
+        """
+        filename = os.path.expanduser(filename)
+        filename = os.path.expandvars(filename)
+        if value_class is None:
+            self._value_class = Value
+        else:
+            self._value_class = value_class
+        self._tablename = (
+            self._value_class.__name__
+            if tablename is None or tablename == "_Settings"
+            else tablename
+        )
+
+        self._filename = os.fspath(filename)
+        self._timeout: float = TIMEOUT if timeout is None else float(timeout)
+        self._local = threading.local()
+
+        # precreated statements based on tablename and value_class
+        tablename = self._escape_table_name(self._tablename)
+        value_columns = self.get_fields(self._value_class)
+        fields = ", ".join(f"{field}" for field in value_columns)
+        self._statements: dict[str, str] = {
+            "GET": f"SELECT {fields} FROM {tablename} WHERE _key = ? LIMIT 1",
+            "CONTAINS": f"SELECT _key FROM {tablename} WHERE _key = ? LIMIT 1",
+            "ITER": f"SELECT _key FROM {tablename} ORDER BY rowid ASC",
+            "REVERSED": f"SELECT _key FROM {tablename} ORDER BY rowid DESC",
+            "COUNT": f"SELECT COUNT (_key) FROM {tablename}",
+            "QUERY": f"SELECT _key, {fields} FROM {tablename}",
+        }
+
+    @staticmethod
+    def get_fields(value_class):
+        value_columns = tuple(value_class._fields)
+        if "_key" in value_columns:
+            raise ValueError(
+                f"Name _key is not allowed as attribute for {value_class},"
+                " listed as field name in _fields."
+            )
+
+        return value_columns
+
+    @staticmethod
+    def _escape_table_name(name: str) -> str:
+        tablename = '"' + name.replace('"', '""') + '"'
+        return tablename
+
+    @property
+    def filename(self) -> str:
+        """DiskStore filename for DB."""
+        return self._filename
+
+    @property
+    def timeout(self) -> float:
+        """SQLite connection timeout value in seconds."""
+        return self._timeout
+
+    @property
+    def tablename(self) -> str:
+        return self._tablename
+
+    @property
+    def _con(self) -> Connection:
+        # Check process ID to support process forking. If the process
+        # ID changes, close the connection and update the process ID.
+
+        local_pid = getattr(self._local, "pid", None)
+        pid: int = os.getpid()
+
+        if local_pid != pid:
+            self.close()
+            self._local.pid: int = pid
+
+        con = getattr(self._local, "con", None)
+
+        if con is None:
+            con = self._local.con = Connection(
+                self._filename, flags=apsw.SQLITE_OPEN_READONLY
+            )
+            con.set_busy_timeout(int(self._timeout * 1000))
+
+        return con
+
+    @contextmanager
+    def _cursor(self):
+        cursor: Cursor = self._con.cursor()
+        try:
+            yield cursor
+        finally:
+            cursor.close()
+
+    def __getitem__(self, key: KeyType):
+        select = self._statements["GET"]
+        with self._cursor() as cursor:
+            row = next(cursor.execute(select, (key,)), MISSING)
+
+        if row is MISSING:
+            raise KeyError(key)
+
+        return self._value_class(*row)  # ty:ignore[not-iterable]
+
+    def keys(self):
+        return DiskKeysView(self)
+
+    def values(self):
+        return DiskValuesView(self)
+
+    def items(self):
+        return DiskItemsView(self)
+
+    def query(
+        self,
+        where: Optional[str] = None,
+        parameters: Optional[Sequence] = None,
+        order: Optional[str] = None,
+    ) -> Generator[tuple, None, None]:
+        where = " WHERE " + where if where else ""
+        parameters = () if parameters is None else parameters
+        order = " ORDER BY " + order if order else ""
+        select = self._statements["QUERY"] + where + order
+
+        with self._cursor() as cursor:
+            cursor.execute(select, parameters)
+            for row in cursor:
+                yield row[0], self._value_class(*row[1:])
+
+    def __contains__(self, key: object) -> bool:
+        with self._cursor() as cx:
+            rows = cx.execute(self._statements["CONTAINS"], (key,)).fetchall()
+
+        return bool(rows)
+
+    def __iter__(self):
+        with self._cursor() as cx:
+            cx.execute(self._statements["ITER"])
+            for row in cx:
+                yield row[0]
+
+    def __reversed__(self):
+        with self._cursor() as cx:
+            cx.execute(self._statements["REVERSED"])
+            for row in cx:
+                yield row[0]
+
+    def close(self) -> None:
+        con = getattr(self._local, "con", None)
+        if con is None:
+            return
+        con.close()
+        try:
+            delattr(self._local, "con")
+        except AttributeError:
+            pass
+
+    def __enter__(self):
+        connection = self._con  # noqa
+        return self
+
+    def __exit__(self, *args, **kwargs) -> None:
+        self.close()
+
+    def __len__(self):
+        select = self._statements["COUNT"]
+
+        with closing(self._con.execute(select)) as cx:
+            rows = next(cx, (0,))
+        return rows[0]
+
+    def __getstate__(self):
+        return {
+            "filename": self.filename,
+            "timeout": self.timeout,
+            "tablename": self._tablename,
+            "value_class": self._value_class,
+        }
+
+    def __setstate__(self, state) -> None:
+        self.__init__(**state)

diskstore/diskstore.py

@@ -0,0 +1,315 @@
+"""DiskStore (MutableMapping) API."""
+
+import os
+import os.path
+import threading
+from collections.abc import Mapping, MutableMapping
+from contextlib import closing, contextmanager
+from time import sleep, time
+from typing import Iterable
+
+import apsw
+
+from .const import DEFAULT_PRAGMAS, MISSING, TIMEOUT, KeyType
+from .diskread import DiskRead
+
+Connection = apsw.Connection
+Cursor = apsw.Cursor
+SQLError = apsw.SQLError
+BusyError = apsw.BusyError
+
+
+class DiskStore(DiskRead, MutableMapping):
+    """SQLite disk storage."""
+
+    def __init__(  # noqa: PLR0915
+        self,
+        filename: os.PathLike | str,
+        value_class=None,
+        tablename: str | None = None,
+        key_type=None,
+        timeout: float | None = None,
+        alter_table: bool = True,
+        **pragmas,
+    ) -> None:
+        """Initialize Diskstore instance.
+
+        :param str filename: DiskStore DB filename.
+                              If not set a tmp directory and default DB name is created.
+        :param str tablename: Optional table name to use.
+                              If not set the name from value_class is used.
+        :param type value_class: Class type (inherited from NamedTuple)
+                                 used to get back data. Default is Value class.
+        :param float timeout: SQLite connection timeout
+                              (also used if DB is busy to retry)
+        :param pragmas: Any of DEFAULT_PRAGMAS or additional PRAGMA's to apply
+        """
+        super().__init__(
+            filename=filename,
+            value_class=value_class,
+            tablename=tablename,
+            timeout=timeout,
+        )
+        self._txn_id = None
+        tablename = self._escape_table_name(self._tablename)
+
+        primary_key_type = "BLOB"
+        if key_type is str:
+            primary_key_type = "TEXT"
+        elif key_type is int:
+            primary_key_type = "INTEGER"
+        elif key_type is float:
+            primary_key_type = "REAL"
+        value_columns = self.get_fields(self._value_class)
+        column_types = self.get_field_types(self._value_class)
+        fields_create = ", ".join(
+            f"{field} {ctype} NOT NULL"
+            for field, ctype in zip(value_columns, column_types, strict=True)
+        )
+        fields = ", ".join(f"{field}" for field in value_columns)
+        excluded_fields = ", ".join(
+            f"{field} = excluded.{field}" for field in value_columns
+        )
+        qms = ", ".join("?" for field in value_columns)
+        self._statements.update(
+            {
+                "CREATE": (
+                    f"CREATE TABLE IF NOT EXISTS {tablename} ("
+                    f" _key {primary_key_type} PRIMARY KEY NOT NULL"
+                    f", {fields_create})"
+                ),
+                "SET": (
+                    f"INSERT INTO {tablename}(_key, {fields}) VALUES (?, {qms})"
+                    f" ON CONFLICT (_key) DO UPDATE SET {excluded_fields}"
+                ),
+                "ADD": (
+                    f"INSERT INTO {tablename}(_key, {fields}) "
+                    f"VALUES (?, {qms}) ON CONFLICT DO NOTHING RETURNING _key"
+                ),
+                "DELETE": f"DELETE FROM {tablename} WHERE _key = ? RETURNING _key",
+                "CLEAR": f"DELETE FROM {tablename};VACUUM;",
+                "POPITEM": (
+                    f"SELECT _key, {fields} FROM {tablename} ORDER BY"
+                    " rowid DESC LIMIT 1"
+                ),
+            }
+        )
+        self._pragmas = DEFAULT_PRAGMAS.copy()
+        self._pragmas.update(pragmas)
+        sql = self._con.execute
+        # Setup table.
+        with closing(sql(self._statements["CREATE"])):
+            pass
+        # try alter table if needed
+        if alter_table:
+            self._alter_table(sql)
+
+    @staticmethod
+    def get_field_types(value_class):
+        value_columns = tuple(value_class._fields)
+        if hasattr(value_class, "__annotations__") and value_class.__annotations__:
+            type_annotations = value_class.__annotations__
+            value_types = []
+            for c_name in value_columns:
+                type_cls = type_annotations.get(c_name, bytes)  # types are optional
+                if type_cls is str:
+                    value_types.append("TEXT")
+                elif type_cls is int:
+                    value_types.append("INTEGER")
+                elif type_cls is float:
+                    value_types.append("REAL")
+                else:
+                    value_types.append("BLOB")
+        else:
+            value_types = ["BLOB" for _ in value_columns]
+
+        return value_types
+
+    def _validate_value(self, value):
+        if isinstance(value, self._value_class):
+            return value
+        value_type = type(value)
+        raise ValueError(
+            f"Value must be instance of {self._value_class} but is {value_type}."
+        )
+
+    @property
+    def _con(self) -> Connection:
+        # Check process ID to support process forking. If the process
+        # ID changes, close the connection and update the process ID.
+
+        local_pid = getattr(self._local, "pid", None)
+        pid: int = os.getpid()
+
+        if local_pid != pid:
+            self.close()
+            self._local.pid: int = pid
+
+        con = getattr(self._local, "con", None)
+
+        if con is None:
+            con = self._local.con = Connection(self._filename)
+            con.set_busy_timeout(int(self._timeout * 1000))
+
+            # Some SQLite pragmas work on a per-connection basis so
+            # apply them all on fresh connection
+            for key, value in self._pragmas.items():
+                con.pragma(key, value)
+
+        return con
+
+    def _alter_table(self, sql):
+        value_columns = self.get_fields(self._value_class)
+        column_types = self.get_field_types(self._value_class)
+        tablename = self._escape_table_name(self._tablename)
+        value_column_defaults = getattr(self._value_class, "_field_defaults", {})
+        existing_fileds = set()
+        table_info_stmt = f"PRAGMA table_info({tablename});"
+        with closing(sql(table_info_stmt)) as cursor:
+            for row in cursor:
+                existing_fileds.add(row[1])
+        for columnname, columntype in zip(value_columns, column_types, strict=True):
+            if columnname not in existing_fileds:
+                default = apsw.format_sql_value(value_column_defaults[columnname])
+                alter_stmt = (
+                    f"ALTER TABLE {tablename} ADD COLUMN {columnname}"
+                    f" {columntype} NOT NULL DEFAULT {default};"
+                )
+                with closing(sql(alter_stmt)) as cursor:
+                    pass
+
+    @contextmanager
+    def transact(self, retry=False):
+        cursor: Cursor = self._con.cursor()
+        tid = threading.get_ident()
+        txn_id = self._txn_id
+        retry_until = time() + TIMEOUT
+
+        if tid == txn_id:  # already inside a thread with a transaction
+            begin = False
+        else:
+            while True:
+                try:
+                    cursor.execute("BEGIN IMMEDIATE")
+                    begin = True
+                    self._txn_id = tid
+                    break
+                except BusyError:
+                    if retry and time() < retry_until:
+                        sleep(0.001)
+                        continue
+                    raise
+
+        try:
+            yield cursor
+        except BaseException:
+            if begin:
+                assert self._txn_id == tid
+                self._txn_id = None
+                cursor.execute("ROLLBACK")
+            cursor.close()
+            raise
+        else:
+            if begin:
+                assert self._txn_id == tid
+                self._txn_id = None
+                cursor.execute("COMMIT")
+            cursor.close()
+
+    def __setitem__(self, key: KeyType, value: Iterable) -> None:
+        value = self._validate_value(value)
+        with self._cursor() as cursor:
+            cursor.execute(self._statements["SET"], (key, *value))
+
+    def add(self, key: KeyType | None, value: Iterable) -> KeyType | None:
+        value = self._validate_value(value)
+        with self._cursor() as cx:
+            rows = cx.execute(self._statements["ADD"], (key, *value)).fetchall()
+
+        if not rows:
+            return None
+
+        return rows[0][0]
+
+    def pop(self, key: KeyType, default=MISSING):  # noqa: E501
+        with self.transact(retry=True) as cx:
+            value = next(cx.execute(self._statements["GET"], (key,)), None)
+            if value is None:
+                if default is MISSING:
+                    raise KeyError(key)
+                return default
+            cx.execute(self._statements["DELETE"], (key,))
+            return self._value_class(*value)
+
+    def popitem(self):
+        with self.transact(retry=True) as cx:
+            row = next(cx.execute(self._statements["POPITEM"]), None)
+            if not row:
+                raise KeyError()
+            key = row[0]
+            value = self._value_class(*row[1:])
+            cx.execute(self._statements["DELETE"], (key,))
+            return key, value
+
+    def __delitem__(self, key: KeyType) -> None:
+        with self._cursor() as cursor:
+            rows = cursor.execute(self._statements["DELETE"], (key,)).fetchall()
+        if not rows:
+            raise KeyError(key)
+
+    def setdefault(self, key: KeyType, default: Iterable | None = None):
+        try:
+            return self[key]
+        except KeyError:
+            if default is not None:
+                default = self._validate_value(default)
+                self.add(key, default)
+
+        return default
+
+    def check(self, vacuum=False):
+        warns = []
+        sql = self._con.execute
+
+        # Check integrity of database.
+        with closing(sql("PRAGMA integrity_check")) as cx:
+            rows = cx.fetchall()
+
+        if len(rows) != 1 or rows[0][0] != "ok":
+            for (message,) in rows:
+                warns.append(message)
+
+        if vacuum:
+            with closing(sql("VACUUM")):
+                pass
+
+        return warns
+
+    def clear(self) -> None:
+        with closing(self._con.execute(self._statements["CLEAR"])):
+            pass
+
+    def update(self, other=(), /, **kwargs):  # type: ignore
+        comps = []
+        if other:
+            if isinstance(other, Mapping):
+                comp = ((key, *value) for key, value in other.items())
+                comps.append(comp)
+            elif hasattr(other, "keys"):
+                comp = ((key, *other[key]) for key in other.keys())
+                comps.append(comp)
+            else:
+                comp = ((key, *value) for key, value in other)
+                comps.append(comp)
+        if kwargs:
+            comp = ((key, *value) for key, value in kwargs.items())
+            comps.append(comp)
+
+        with self.transact(retry=True) as cursor:
+            for comp in comps:
+                cursor.executemany(self._statements["SET"], comp)
+
+    def get_readonly_instance(self):
+        return DiskRead(
+            self._filename, self._value_class, self._tablename, self._timeout
+        )

diskstore-0.1.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.3
+Name: diskstore
+Version: 0.1.0
+Summary: Simple MutableMapping compatible SQLite based disk storage.
+Author: tds333
+Author-email: tds333 <tds333@mailbox.org>
+Requires-Dist: apsw
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# DiskStore Sqlite based disk store
+
+`DiskStore` is an Apache2/MIT licensed disk storage library, written
+in pure Python.
+
+Inspired by DiskCache library it implements a MutableMapping compatible sqlite
+based disk storage. Easy interface and very fast. Keys can be of basic sqlite storage
+classes defined by Python types `int`, `float`, `str`, `bytes`. Value is a `Namedtuple` class
+with same basic Python types.
+
+
+## Features
+
+- Pure-Python
+- nearly 100% test coverage
+- Performance matters
+- Thread-safe and process-safe
+- Developed on Python 3.10
+- Tested on CPython 3.10, 3.11, 3.12, 3.13, 3.14, 3.15
+- Tested using GitHub Actions
+
+
+## Quickstart
+
+Installing `DiskStore`:
+
+  $ uv pip install diskstore
+
+or
+
+  $ uv add diskstore
+
+There are three basic storage classes available.
+`DiskStore`, `DiskRead` and `DiskCache`.
+
+## User Guide
+
+Work in progress, look at unit tests for examples.
+
+Example:
+
+```python
+
+from diskstore import DiskStore, Value
+
+ds = DiskStore("/tmp/diskstore.db", value_class=Value)
+ds["key"] = Value("my value")
+print(ds["key"])
+
+```
+
+Everything is mostly stable and test coverage is nearly 100%. Documentation is missing.
+
+### Timings
+
+These are rough measurements. Compared to Diskcache library.
+
+Diskstore library:
+
+set: 28.8 µs
+get: 3.23 µs
+set/delete: 84 µs
+
+Diskcache library:
+
+set: 196 µs
+get: 15.5 µs
+set/delete: 535 µs
+
+
+Why is the Diskstore library faster than others. Every overhead is eliminitated and it uses the
+faster sqlite library apsw with up to date sqlite library version. 
+
+
+License
+-------
+
+Copyright 2025-2026 Wolfgang Langner
+
+Licensed under the Apache License, Version 2.0 (the "License") or MIT; 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
+    https://mit-license.org/
+
+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.

diskstore-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+diskstore/__init__.py,sha256=7ZZHY-ok2S01xGdZ9jebyaFtXGz3ddMAbvw1LZnQYt0,198
+diskstore/const.py,sha256=VPBso0bMQyvrwUmAriseWbdrfBRndLErk5340jUh0z4,498
+diskstore/diskcache.py,sha256=jadCJ1WRJgvpnUpC409nQVLWLRtCknbi8HERFfGwLu4,3743
+diskstore/diskread.py,sha256=r8FA_Nn0iDZQ5ssXWVVnA-R3XyBrRuVvI6NHycZFz9E,8063
+diskstore/diskstore.py,sha256=_p3gZXhbaq6EY4TOas8zKB76F1ZO03TEAv2pauut37U,11162
+diskstore-0.1.0.dist-info/WHEEL,sha256=jROcLULcdzropX2J55opKw4UHhPFREZax2XzS-Mvpxs,80
+diskstore-0.1.0.dist-info/METADATA,sha256=vw7LuKhkEFK4YbmpAT0S6wrMm4cuz8-no3IkORlS1ks,2406
+diskstore-0.1.0.dist-info/RECORD,,

diskstore-0.1.0.dist-info/WHEEL

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