dictature 0.9.0__py3-none-any.whl

dictature/__init__.py

@@ -0,0 +1 @@
+from .dictature import Dictature

dictature/backend/__init__.py

@@ -0,0 +1,3 @@
+from .mock import DictatureBackendMock, ValueMode, Value
+from .directory import DictatureBackendDirectory
+from .sqlite import DictatureBackendSQLite

dictature/backend/directory.py

@@ -0,0 +1,79 @@
+from re import sub
+from json import dumps, loads
+from pathlib import Path
+from typing import Iterable, Union
+from shutil import rmtree
+
+from .mock import DictatureTableMock, DictatureBackendMock, Value, ValueMode
+
+
+class DictatureBackendDirectory(DictatureBackendMock):
+    def __init__(self, directory: Union[Path, str], dir_prefix: str = 'db_') -> None:
+        if isinstance(directory, str):
+            directory = Path(directory)
+        self.__directory = directory
+        self.__dir_prefix = dir_prefix
+
+    def keys(self) -> Iterable[str]:
+        for child in self.__directory.iterdir():
+            if child.is_dir() and child.name.startswith(self.__dir_prefix):
+                yield child.name[len(self.__dir_prefix):]
+
+    def table(self, name: str) -> 'DictatureTableMock':
+        return DictatureTableDirectory(self.__directory, name, self.__dir_prefix)
+
+
+class DictatureTableDirectory(DictatureTableMock):
+    def __init__(self, path_root: Path, name: str, db_prefix: str, prefix: str = 'item_') -> None:
+        self.__path = path_root / (db_prefix + self.__filename_encode(name, suffix=''))
+        self.__prefix = prefix
+
+    def keys(self) -> Iterable[str]:
+        for child in self.__path.iterdir():
+            if child.is_file() and child.name.startswith(self.__prefix) and not child.name.endswith('.tmp'):
+                yield self.__filename_decode(child.name[len(self.__prefix):])
+
+    def drop(self) -> None:
+        rmtree(self.__path)
+
+    def create(self) -> None:
+        self.__path.mkdir(parents=True, exist_ok=True)
+
+    def set(self, item: str, value: Value) -> None:
+        file_target = self.__item_path(item)
+        file_target_tmp = file_target.with_suffix('.tmp')
+
+        save_as_json = value.mode != ValueMode.string.value or value.value.startswith('{')
+        save_data = dumps({'value': value.value, 'mode': value.mode}, indent=1) if save_as_json else value.value
+
+        file_target_tmp.write_text(save_data)
+        file_target_tmp.rename(file_target)
+
+    def get(self, item: str) -> Value:
+        try:
+            save_data = self.__item_path(item).read_text()
+            if save_data.startswith('{'):
+                data = loads(save_data)
+                return Value(data['value'], data['mode'])
+            return Value(save_data, ValueMode.string.value)
+        except FileNotFoundError:
+            raise KeyError(item)
+
+    def delete(self, item: str) -> None:
+        if self.__item_path(item).exists():
+            self.__item_path(item).unlink()
+
+    def __item_path(self, item: str) -> Path:
+        return self.__path / (self.__prefix + self.__filename_encode(item))
+
+    @staticmethod
+    def __filename_encode(name: str, suffix: str = '.txt') -> str:
+        if name == sub(r'[^\w_. -]', '_', name):
+            return f"d_{name}{suffix}"
+        return f'e_{name.encode('utf-8').hex()}{suffix}'
+
+    @staticmethod
+    def __filename_decode(name: str) -> str:
+        if name.startswith('d_'):
+            return name[2:-5]
+        return bytes.fromhex(name[2:-5]).decode('utf-8')

dictature/backend/mock.py

@@ -0,0 +1,41 @@
+from typing import Iterable, NamedTuple
+from enum import Enum
+
+
+class ValueMode(Enum):
+    string = 0
+    json = 1
+    pickle = 2
+
+
+class Value(NamedTuple):
+    value: str
+    mode: int
+
+
+class DictatureBackendMock:
+    def keys(self) -> Iterable[str]:
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def table(self, name: str) -> 'DictatureTableMock':
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+
+class DictatureTableMock:
+    def keys(self) -> Iterable[str]:
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def drop(self) -> None:
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def create(self) -> None:
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def set(self, item: str, value: Value) -> None:
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def get(self, item: str) -> Value:
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def delete(self, item: str) -> None:
+        raise NotImplementedError("This method should be implemented by the subclass")

dictature/backend/sqlite.py

@@ -0,0 +1,137 @@
+import sqlite3
+from typing import Iterable, Union, Optional
+from pathlib import Path
+
+from .mock import DictatureBackendMock, DictatureTableMock, Value, ValueMode
+
+
+class DictatureBackendSQLite(DictatureBackendMock):
+    def __init__(self, file: Union[str, Path]) -> None:
+        if isinstance(file, str):
+            file = Path(file)
+        self.__file = file
+        self.__connection = sqlite3.connect(
+            f"{self.__file.absolute()}",
+            check_same_thread=False if sqlite3.threadsafety >= 3 else True
+        )
+        self.__cursor = self.__connection.cursor()
+
+    def keys(self) -> Iterable[str]:
+        tables = self._execute("SELECT tbl_name FROM sqlite_master WHERE type='table' AND tbl_name LIKE 'db_%'")
+        return {table[0][3:] for table in tables}
+
+    def table(self, name: str) -> 'DictatureTableMock':
+        return DictatureTableSQLite(self, name)
+
+    def _execute(self, query: str, data: tuple = ()) -> list:
+        return list(self.__cursor.execute(query, data))
+
+    def _commit(self) -> None:
+        self.__connection.commit()
+
+    def __del__(self):
+        self.__connection.close()
+
+
+
+class DictatureTableSQLite(DictatureTableMock):
+    def __init__(self, parent: "DictatureBackendSQLite", name: str) -> None:
+        self.__parent = parent
+        self.__supports_jsonization: Optional[bool] = None
+        self.__table = "`tb_%s`" % name.replace('`', '``')
+
+    def keys(self) -> Iterable[str]:
+        # noinspection PyProtectedMember
+        return set(map(lambda x: x[0], self.__parent._execute(f"SELECT key FROM {self.__table}")))
+
+    def drop(self) -> None:
+        # noinspection PyProtectedMember
+        self.__parent._execute(f"DROP TABLE {self.__table}")
+
+    def key_exists(self, item: str) -> bool:
+        # noinspection PyProtectedMember
+        return not not self.__parent._execute(f"SELECT value FROM {self.__table} WHERE key=?", (item,))
+
+    def create(self) -> None:
+        # noinspection PyProtectedMember
+        self.__parent._execute(f"""
+        CREATE TABLE IF NOT EXISTS {self.__table} (
+        `key`	TEXT NOT NULL UNIQUE,
+        `value`	TEXT
+        );
+        """)
+
+    def set(self, item: str, value: Value) -> None:
+        if value.mode != ValueMode.string:
+            self.__support_jsonization()
+
+        if self.key_exists(item):
+            if self.__test_supports_jsonization():
+                # noinspection PyProtectedMember
+                self.__parent._execute(f"""
+                UPDATE {self.__table} SET value=?, jsonized=? WHERE key=?
+                """, (value.value, value.mode, item))
+            else:
+                # noinspection PyProtectedMember
+                self.__parent._execute(f"UPDATE {self.__table} SET value=? WHERE key=?", (value.value, item))
+        else:
+            if self.__test_supports_jsonization():
+                # noinspection PyProtectedMember
+                self.__parent._execute(
+                    f"INSERT INTO {self.__table} (`key`,`value`,`jsonized`) VALUES (?,?,?);",
+                    (item, value.value, value.mode)
+                )
+            else:
+                # noinspection PyProtectedMember
+                self.__parent._execute(
+                    f"INSERT INTO {self.__table} (`key`,`value`) VALUES (?,?);", (item, value.value)
+                )
+        # noinspection PyProtectedMember
+        self.__parent._commit()
+
+    def get(self, item: str) -> Value:
+        if self.__test_supports_jsonization():
+            cmd = f"SELECT value, jsonized FROM {self.__table} WHERE key=?"
+        else:
+            cmd = f"SELECT value FROM {self.__table} WHERE key=?"
+
+        # noinspection PyProtectedMember
+        r = self.__parent._execute(cmd, (item,))
+        if r:
+            value: str = r[0][0]
+
+            if self.__supports_jsonization:
+                jsonized_state: int = r[0][1]
+            else:
+                jsonized_state = ValueMode.string.value
+
+            return Value(value=value, mode=jsonized_state)
+        raise KeyError(item)
+
+    def delete(self, item: str) -> None:
+        # noinspection PyProtectedMember
+        self.__parent._execute(
+            f"DELETE FROM {self.__table} WHERE `key`=?;", (item,)
+        )
+        # noinspection PyProtectedMember
+        self.__parent._commit()
+
+    def __test_supports_jsonization(self) -> bool:
+        if self.__supports_jsonization is not None:
+            return self.__supports_jsonization
+        # noinspection PyProtectedMember
+        for _, column_name, _, _, _, _ in self.__parent._execute(f"PRAGMA table_info({self.__table})"):
+            if column_name == 'jsonized':
+                self.__supports_jsonization = True
+                return True
+        self.__supports_jsonization = False
+        return False
+
+    def __support_jsonization(self) -> None:
+        if self.__supports_jsonization or self.__test_supports_jsonization():
+            return
+        # noinspection PyProtectedMember
+        self.__parent._execute(f"""
+        ALTER TABLE {self.__table} ADD COLUMN jsonized INTEGER NOT NULL DEFAULT 0
+        """)
+        self.__supports_jsonization = True

dictature/dictature.py

@@ -0,0 +1,126 @@
+import json
+import pickle
+from gzip import compress, decompress
+from base64 import b64encode, b64decode
+from random import choice
+from typing import Optional, Dict, Any, Set, Iterator, Tuple
+
+from .backend import DictatureBackendMock, ValueMode, Value
+
+
+class Dictature:
+    def __init__(self, backend: DictatureBackendMock) -> None:
+        self.__db = backend
+        self.__db_cache: Dict[str, "DictatureTable"] = {}
+
+    def keys(self) -> Set[str]:
+        return set(self.__db.keys())
+
+    def values(self) -> Iterator["DictatureTable"]:
+        return map(lambda x: x[1], self.items())
+
+    def items(self) -> Iterator[Tuple[str, "DictatureTable"]]:
+        for k in self.keys():
+            yield k, self[k]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {k: v.to_dict() for k, v in self.items()}
+
+    def __str__(self):
+        return str(self.to_dict())
+
+    def __getitem__(self, item: str) -> "DictatureTable":
+        if len(self.__db_cache) > 128:
+            del self.__db_cache[choice(list(self.__db_cache.keys()))]
+        if item not in self.__db_cache:
+            self.__db_cache[item] = DictatureTable(self.__db, item)
+        return self.__db_cache[item]
+
+    def __delitem__(self, key: str) -> None:
+        self[key].drop()
+
+    def __contains__(self, item: str) -> bool:
+        return item in self.keys()
+
+    def __bool__(self) -> bool:
+        return not not self.keys()
+
+
+class DictatureTable:
+    def __init__(self, db: DictatureBackendMock, table_name: str):
+        self.__db = db
+        self.__table = self.__db.table(table_name)
+        self.__table_created = False
+
+    def get(self, item: str, default: Optional[Any] = None) -> Any:
+        try:
+            return self[item]
+        except KeyError:
+            return default
+
+    def key_exists(self, item: str) -> bool:
+        self.__create_table()
+        return item in self.keys()
+
+    def keys(self) -> Set[str]:
+        self.__create_table()
+        return set(self.__table.keys())
+
+    def values(self) -> Iterator[Any]:
+        return map(lambda x: x[1], self.items())
+
+    def items(self) -> Iterator[Tuple[str, Any]]:
+        for k in self.keys():
+            yield k, self[k]
+
+    def drop(self) -> None:
+        self.__create_table()
+        self.__table.drop()
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {k: v for k, v in self.items()}
+
+    def __str__(self):
+        return str(self.to_dict())
+
+    def __getitem__(self, item: str) -> Any:
+        self.__create_table()
+        value = self.__table.get(item)
+        mode = ValueMode(value.mode)
+        match mode:
+            case ValueMode.string:
+                return value.value
+            case ValueMode.json:
+                return json.loads(value.value)
+            case ValueMode.pickle:
+                return pickle.loads(decompress(b64decode(value.value.encode('ascii'))))
+        raise ValueError(f"Unknown mode '{value.mode}'")
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.__create_table()
+        value_mode = ValueMode.string
+
+        if type(value) is not str:
+            try:
+                value = json.dumps(value)
+                value_mode = ValueMode.json
+            except TypeError:
+                value = b64encode(compress(pickle.dumps(value))).decode('ascii')
+                value_mode = value_mode.pickle
+
+        self.__table.set(key, Value(value=value, mode=value_mode.value))
+
+    def __delitem__(self, key: str) -> None:
+        self.__table.delete(key)
+
+    def __contains__(self, item: str):
+        return item in self.keys()
+
+    def __bool__(self) -> bool:
+        return not not self.keys()
+
+    def __create_table(self) -> None:
+        if self.__table_created:
+            return
+        self.__table.create()
+        self.__table_created = True

dictature-0.9.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Adam Hlaváček
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dictature-0.9.0.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.1
+Name: dictature
+Version: 0.9.0
+Summary: dictature -- A generic wrapper around dict-like interface with mulitple backends
+Author-email: Adam Hlavacek <git@adamhlavacek.com>
+Project-URL: Homepage, https://github.com/esoadamo/dictature
+Project-URL: Issues, https://github.com/esoadamo/dictature/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# SQLiDictature
+
+A wrapper for Python's dictionary with multiple backends.
+
+## Installation
+
+```shell
+pip install dictature
+```
+
+## Dictature usage
+This package also includes a class that allows you to use your SQLite db as a Python dictionary:
+
+```python
+from dictature import Dictature
+from dictature.backend import DictatureBackendDirectory, DictatureBackendSQLite
+
+# will use/create the db directory
+# dictionary = Dictature(DictatureBackendDirectory('test_data'))
+# will use/create the db file
+dictionary = Dictature(DictatureBackendSQLite('test_data.sqlite3'))
+
+# will create a table db_test and there a row called foo with value bar
+dictionary['test']['foo'] = 'bar'
+
+# also support anything that can be jsonized
+dictionary['test']['list'] = ['1', 2, True]
+print(dictionary['test']['list'])  # prints ['1', 2, True]
+
+# or anything, really (that can be serialized with pickle)
+from threading import Thread
+dictionary['test']['thread'] = Thread
+print(dictionary['test']['thread'])  # prints <class 'threading.Thread'>
+
+# and deleting
+del dictionary['test']['list']  # deletes the record
+del dictionary['test']  # drops whole table
+```

dictature-0.9.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+dictature/__init__.py,sha256=UCPJKHeyirRZ0pCYoyeat-rwXa8pDezOJ3UWCipDdyc,33
+dictature/dictature.py,sha256=CwIK8pQyFq7JTqF_CEhqE4_w0TXlxZAVLfO0wRccCcU,3800
+dictature/backend/__init__.py,sha256=d5s6QCJOUzFglVNg8Cqqx_8b61S-AOTGjEUIF6FS69U,149
+dictature/backend/directory.py,sha256=xdjXL7pBh_sG85sST6nZIruWVS8aJnUrk4erEEslaU4,3054
+dictature/backend/mock.py,sha256=Qd7KSh-qM763Jc7biDf5xYFWdgDax30dUHh2gXWwTZE,1266
+dictature/backend/sqlite.py,sha256=VvEivK40NNGhOc-J4y9b81Fs9RDaDUw1jHXqKxqZQqI,5130
+dictature-0.9.0.dist-info/LICENSE,sha256=n1U9DKr8sM5EY2QHcvxSGiKTDWUT8MyXsOC79w94MT0,1072
+dictature-0.9.0.dist-info/METADATA,sha256=T5PMGmS_ceBGoXTDHn5W2iMp4v-ftL0zd825aPJ4DcY,1670
+dictature-0.9.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+dictature-0.9.0.dist-info/top_level.txt,sha256=-RO39WWCF44lqiXhSUcACVqbk6SkgReZTz7ZmHKH3-U,10
+dictature-0.9.0.dist-info/RECORD,,

dictature-0.9.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dictature-0.9.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dictature