diskstore 0.2.0__tar.gz → 0.4.0__tar.gz

diskstore-0.4.0/LICENSE.txt

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025-2026 Wolfgang Langner
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

{diskstore-0.2.0 → diskstore-0.4.0}/PKG-INFO

@@ -1,16 +1,18 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: diskstore
-Version: 0.2.0
+Version: 0.4.0
 Summary: Simple MutableMapping compatible SQLite based disk storage.
 Author: tds333
 Author-email: tds333 <tds333@mailbox.org>
+License-Expression: BSD-3-Clause
+License-File: LICENSE.txt
 Requires-Dist: apsw>=3.51.3
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 
 # DiskStore Sqlite based disk store
 
-`DiskStore` is an Apache2/MIT licensed disk storage library, written
+`DiskStore` is a BSD-3-Clause licensed disk storage library, written
 in pure Python.
 
 Inspired by DiskCache library it implements a MutableMapping compatible sqlite
@@ -85,16 +87,7 @@ 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
+`DiskStore` is distributed under the terms of the
+[BSD-3-Clause](https://spdx.org/licenses/BSD-3-Clause.html) license.
 
-    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.
+Copyright 2025-2026 Wolfgang Langner

{diskstore-0.2.0 → diskstore-0.4.0}/README.md

@@ -1,6 +1,6 @@
 # DiskStore Sqlite based disk store
 
-`DiskStore` is an Apache2/MIT licensed disk storage library, written
+`DiskStore` is a BSD-3-Clause licensed disk storage library, written
 in pure Python.
 
 Inspired by DiskCache library it implements a MutableMapping compatible sqlite
@@ -75,16 +75,7 @@ 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
+`DiskStore` is distributed under the terms of the
+[BSD-3-Clause](https://spdx.org/licenses/BSD-3-Clause.html) license.
 
-    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.
+Copyright 2025-2026 Wolfgang Langner

diskstore-0.4.0/pyproject.toml

@@ -0,0 +1,80 @@
+[project]
+name = "diskstore"
+version = "0.4.0"
+description = "Simple MutableMapping compatible SQLite based disk storage."
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE.txt"]
+requires-python = ">=3.10"
+dependencies = ["apsw>=3.51.3"]
+
+[[project.authors]]
+name = "tds333"
+email = "tds333@mailbox.org"
+
+[dependency-groups]
+dev = [
+    "msgspec>=0.20.0",
+    "pydantic>=2.12.5,<=2.99.99b0",
+    "pytest",
+    "pytest-asyncio>=1.3.0",
+    "pytest-cov",
+    "pytest-examples>=0.0.18",
+    "pytest-xdist",
+    "structtype>=0.8.1",
+]
+docs = [
+    "mkdocstrings[python]>=1.0.3",
+    "zensical>=0.0.23",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.2,<1"]
+build-backend = "uv_build"
+
+[tool.coverage.run]
+parallel = true
+branch = true
+source = ["diskstore"]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = true
+exclude_lines = [
+    "no cov",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]
+
+[tool.pytest]
+testpaths = ["tests"]
+
+[tool.ruff]
+exclude = [
+    ".env",
+    ".venv",
+    "venv",
+]
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "W",
+    "F",
+    "I",
+    "C",
+    "B",
+    "PT",
+    "N",
+    "PL",
+    "RUF",
+]
+ignore = [
+    "B008",
+    "C901",
+    "RET504",
+    "PLR2004",
+]
+
+[tool.uv]

diskstore-0.2.0/pyproject.toml → diskstore-0.4.0/pyproject.toml.orig

@@ -1,42 +1,32 @@
 [project]
 name = "diskstore"
-version = "0.2.0"
+version = "0.4.0"
 description = "Simple MutableMapping compatible SQLite based disk storage."
 readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE.txt"]
 requires-python = ">=3.10"
 authors = [{ name = "tds333", email = "tds333@mailbox.org" }]
-dependencies = [
-  "apsw>=3.51.3",
-]
+dependencies = ["apsw>=3.51.3"]
 
 [dependency-groups]
 dev = [
+  "msgspec>=0.20.0",
+  "pydantic>=2.12.5,<=2.99.99b0",
   "pytest",
   "pytest-asyncio>=1.3.0",
   "pytest-cov",
   "pytest-examples>=0.0.18",
   "pytest-xdist",
-]
-benchmark = [
-  "diskcache",
-  "ipython",
-  "pickleDB<1",
-  "pylibmc",
-  "redis",
-  "sqlitedict",
+  "structtype>=0.8.1",
 ]
 docs = [
-  "mkdocs>=1.6.1",
   "mkdocstrings[python]>=1.0.3",
   "zensical>=0.0.23",
 ]
-ext-dev = [
-  "msgspec>=0.20.0",
-  "pydantic>=2.12.5",
-]
 
 [build-system]
-requires = ["uv_build>=0.9.2,<0.12.0"]
+requires = ["uv_build>=0.9.2,<1"]
 build-backend = "uv_build"
 
 [tool.coverage.run]
@@ -78,3 +68,6 @@ ignore = [
   "RET504",
   "PLR2004",
 ]
+
+[tool.uv]
+#exclude-newer = "1 days"

diskstore-0.4.0/src/diskstore/config.py

@@ -0,0 +1,275 @@
+"""DiskStore configuration classes and helpers for config."""
+
+import dataclasses
+import json
+from abc import abstractmethod
+from collections.abc import Sequence
+from typing import Any, Iterable, Protocol
+
+from .const import NO_DEFAULT, TIMEOUT, AnyLite, KeyType
+
+
+def get_sqlite_type(type_) -> str:
+    if type_ in {"BLOB", "TEXT", "INTEGER", "REAL"}:
+        return type_
+    sqlite_type = "BLOB"
+    if type_ is str:
+        sqlite_type = "TEXT"
+    elif type_ is int:
+        sqlite_type = "INTEGER"
+    elif type_ is bool:
+        sqlite_type = "INTEGER"
+    elif type_ is float:
+        sqlite_type = "REAL"
+
+    return sqlite_type
+
+
+def escape_name(name: str) -> str:
+    tablename = '"' + name.replace('"', '""') + '"'
+    return tablename
+
+
+def is_bindable_default(value) -> bool:
+    """Whether *value* can be encoded by apsw as a SQL literal."""
+    return value is None or isinstance(value, (str, bytes, int, float))
+
+
+class ConfigProtocol(Protocol):
+    """Configuration Protocol
+
+    Attributes:
+        tablename: Table name as string
+        key_type: key type as string or basic Python type like str, int, float
+        timeout: Timeout used to wait if someone blocks connections or with writes
+        pragmas: Dictionary with PRAGMAs to set when connections is initialized
+        fields: Iterable used for select, update and create statement with
+            field name, type, default.
+            ``[("value", str, NO_DEFAULT), ("value2", int, 0)]``
+
+    """
+
+    tablename: str
+    key_type: str
+    timeout: float
+    pragmas: dict
+    fields: Iterable
+    auto_migrate: bool
+
+    @abstractmethod
+    def dump_value(self, key: KeyType | None, value: Any) -> Sequence:
+        """Called with the key and value, should return a Sequence
+        with the key as first element, suitable as parameter tuple for
+        the INSERT/SET statement."""
+
+    @abstractmethod
+    def load_data(self, data: tuple) -> Any:
+        """load(db_data): called with the tuple selected from DB,
+        including the key at index 0.  Should be converted to the
+        type normally received as value."""
+
+
+class BaseConfig(ConfigProtocol):
+    """Base default configuratin."""
+
+    def __init__(
+        self,
+        *,
+        tablename=None,
+        key_type=None,
+        timeout=None,
+        pragmas=None,
+        auto_migrate=None,
+    ):
+        self.tablename = "DiskStore" if tablename is None else tablename
+        self.key_type = "BLOB" if key_type is None else get_sqlite_type(key_type)
+        self.timeout = TIMEOUT if timeout is None else float(timeout)
+        self.pragmas = {} if pragmas is None else pragmas
+        self.auto_migrate = True if auto_migrate is None else auto_migrate
+        self.fields = [("value", "BLOB", NO_DEFAULT)]
+
+    def dump_value(self, key: KeyType | None, value: Any) -> Sequence:
+        return (key, value)
+
+    def load_data(self, data: tuple) -> Any:
+        return data[1]
+
+
+class NamedTupleConfig(BaseConfig):
+    def __init__(  # noqa: PLR0913
+        self,
+        value_class,
+        tablename=None,
+        key_type=None,
+        timeout=None,
+        pragmas=None,
+        auto_migrate=None,
+    ):
+        tablename = value_class.__name__ if not tablename else tablename
+        super().__init__(
+            tablename=tablename,
+            key_type=key_type,
+            timeout=timeout,
+            pragmas=pragmas,
+            auto_migrate=auto_migrate,
+        )
+        self.value_class = value_class
+        self.fields = self.get_fields(value_class)
+
+    @staticmethod
+    def get_fields(value_class):
+        fields = []
+        value_columns = tuple(value_class._fields)
+        type_annotations = value_class.__annotations__
+        value_column_defaults: dict[str, AnyLite] = getattr(
+            value_class, "_field_defaults", {}
+        )
+        for name in value_columns:
+            type_cls = type_annotations.get(name, bytes)  # types are optional
+            sqlite_type = get_sqlite_type(type_cls)
+            default = value_column_defaults.get(name, NO_DEFAULT)
+            if not is_bindable_default(default):
+                default = NO_DEFAULT
+            fields.append((name, sqlite_type, default))
+        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 tuple(fields)
+
+    def dump_value(self, key: KeyType | None, value: Any) -> Sequence:
+        return (key, *value)
+
+    def load_data(self, data: tuple) -> Any:
+        return self.value_class._make(data[1:])
+
+
+class JsonConfig(BaseConfig):
+    def __init__(
+        self,
+        tablename=None,
+        key_type=None,
+        timeout=None,
+        pragmas=None,
+        auto_migrate=None,
+    ):
+        super().__init__(
+            tablename=tablename,
+            key_type=key_type,
+            timeout=timeout,
+            pragmas=pragmas,
+            auto_migrate=auto_migrate,
+        )
+        self.fields = (("value", "TEXT", NO_DEFAULT),)
+
+    def dump_value(self, key: KeyType | None, value: Any) -> Sequence:
+        return (key, json.dumps(value))
+
+    def load_data(self, data: tuple) -> Any:
+        return json.loads(data[1])
+
+
+class DataclassConfig(BaseConfig):
+    def __init__(  # noqa: PLR0913
+        self,
+        dataclass,
+        tablename=None,
+        key_type=None,
+        timeout=None,
+        pragmas=None,
+        auto_migrate=None,
+    ):
+        tablename = dataclass.__name__ if not tablename else tablename
+        super().__init__(
+            tablename=tablename,
+            key_type=key_type,
+            timeout=timeout,
+            pragmas=pragmas,
+            auto_migrate=auto_migrate,
+        )
+        self.dataclass = dataclass
+        self.fields = self.get_fields(dataclass)
+
+    @staticmethod
+    def get_fields(dataclass):
+        if not dataclasses.is_dataclass(dataclass):
+            raise ValueError("It is not a dataclass.")
+        dc_fields = dataclasses.fields(dataclass)
+        value_columns = tuple(field.name for field in dc_fields)
+        if "_key" in value_columns:
+            raise ValueError("Name _key is not allowed as attribute for dataclass.")
+        type_annotations = getattr(dataclass, "__annotations__", {}) or {}
+        fields = []
+        for f in dc_fields:
+            type_cls = type_annotations.get(f.name, bytes)
+            sqlite_type = get_sqlite_type(type_cls)
+            if f.default is not dataclasses.MISSING and is_bindable_default(f.default):
+                default = f.default
+            else:
+                default = NO_DEFAULT
+            fields.append((f.name, sqlite_type, default))
+        return tuple(fields)
+
+    def dump_value(self, key: KeyType | None, value: Any) -> Sequence:
+        return (key, *dataclasses.astuple(value))
+
+    def load_data(self, data: tuple) -> Any:
+        return self.dataclass(*data[1:])
+
+
+class PydanticConfig(BaseConfig):
+    def __init__(  # noqa: PLR0913
+        self,
+        model,
+        tablename=None,
+        key_type=None,
+        timeout=None,
+        pragmas=None,
+        auto_migrate=None,
+    ):
+        tablename = model.__name__ if not tablename else tablename
+        super().__init__(
+            tablename=tablename,
+            key_type=key_type,
+            timeout=timeout,
+            pragmas=pragmas,
+            auto_migrate=auto_migrate,
+        )
+        self.fields = (("value", "TEXT", NO_DEFAULT),)
+        self.model = model
+
+    def dump_value(self, key: KeyType | None, value: Any) -> Sequence:
+        return (key, value.model_dump_json())
+
+    def load_data(self, data: tuple) -> Any:
+        return self.model.model_validate_json(data[1])
+
+
+class StructtypeConfig(BaseConfig):
+    def __init__(  # noqa: PLR0913, PLR0917
+        self,
+        struct,
+        tablename=None,
+        key_type=None,
+        timeout=None,
+        pragmas=None,
+        auto_migrate=None,
+    ):
+        tablename = struct.__name__ if not tablename else tablename
+        super().__init__(
+            tablename=tablename,
+            key_type=key_type,
+            timeout=timeout,
+            pragmas=pragmas,
+            auto_migrate=auto_migrate,
+        )
+        self.fields = (("value", "BLOB", NO_DEFAULT),)
+        self.struct = struct
+
+    def dump_value(self, key: KeyType | None, value: Any) -> Sequence:
+        return (key, value.struct_dump_json())
+
+    def load_data(self, data: tuple) -> Any:
+        return self.struct.struct_validate_json(data[1])

{diskstore-0.2.0 → diskstore-0.4.0}/src/diskstore/const.py

@@ -5,19 +5,31 @@ from typing import (
     Union,
 )
 
-TIMEOUT = 60.0
+TIMEOUT = 10.0
 "default timout in seconds"
 
 MISSING = object()
 
 
+class NO_DEFAULT:  # noqa: N801
+    """Sentinel marker for fields without a default value."""
+
+
+DEFAULT_RO_PRAGMAS = {
+    "cache_size": 2**13,  # 8,192 pages
+    "mmap_size": 2**28,  # 256 MB
+    "temp_store": 2,  # 0=DEFAULT, 1=FILE, 2=MEMORY
+    "synchronous": 1,  # 0=OFF, 1=NORMAL, 2=FULL, 3=EXTRA
+}
+"default read only pragma settings"
+
 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",
+    "temp_store": 2,  # 0=DEFAULT, 1=FILE, 2=MEMORY
     # "pargma_busy_timeout": 5000,  # milliseconds
 }
 "default pragma settings"