dictature 0.9.0__tar.gz → 0.9.2__tar.gz

{dictature-0.9.0/src/dictature.egg-info → dictature-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dictature
-Version: 0.9.0
+Version: 0.9.2
 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
@@ -11,7 +11,7 @@ Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-# SQLiDictature
+# Dictature
 
 A wrapper for Python's dictionary with multiple backends.
 
@@ -22,7 +22,7 @@ pip install dictature
 ```
 
 ## Dictature usage
-This package also includes a class that allows you to use your SQLite db as a Python dictionary:
+This package also includes a class that allows you to use your SQLite db or any backend as a Python dictionary:
 
 ```python
 from dictature import Dictature
@@ -49,3 +49,27 @@ print(dictionary['test']['thread'])  # prints <class 'threading.Thread'>
 del dictionary['test']['list']  # deletes the record
 del dictionary['test']  # drops whole table
 ```
+
+Currently, the following backends are supported:
+- `DictatureBackendDirectory`: stores the data in a directory as json files
+- `DictatureBackendSQLite`: stores the data in a SQLite database
+
+### Transformers
+
+You can also use transformers to change how the values are stored. E.g. to encrypt data, you can use the
+`AESTransformer` (which requires the `pycryptodome` package):
+
+```python
+from dictature import Dictature
+from dictature.backend import DictatureBackendDirectory
+from dictature.transformer.aes import AESTransformer
+
+name_transformer = AESTransformer('password1', True)
+value_transformer = AESTransformer('password2', False)
+
+dictionary = Dictature(
+    DictatureBackendSQLite('test_data.sqlite3'),
+    name_transformer=name_transformer,
+    value_transformer=value_transformer
+)
+```

{dictature-0.9.0 → dictature-0.9.2}/README.md

@@ -1,4 +1,4 @@
-# SQLiDictature
+# Dictature
 
 A wrapper for Python's dictionary with multiple backends.
 
@@ -9,7 +9,7 @@ pip install dictature
 ```
 
 ## Dictature usage
-This package also includes a class that allows you to use your SQLite db as a Python dictionary:
+This package also includes a class that allows you to use your SQLite db or any backend as a Python dictionary:
 
 ```python
 from dictature import Dictature
@@ -36,3 +36,27 @@ print(dictionary['test']['thread'])  # prints <class 'threading.Thread'>
 del dictionary['test']['list']  # deletes the record
 del dictionary['test']  # drops whole table
 ```
+
+Currently, the following backends are supported:
+- `DictatureBackendDirectory`: stores the data in a directory as json files
+- `DictatureBackendSQLite`: stores the data in a SQLite database
+
+### Transformers
+
+You can also use transformers to change how the values are stored. E.g. to encrypt data, you can use the
+`AESTransformer` (which requires the `pycryptodome` package):
+
+```python
+from dictature import Dictature
+from dictature.backend import DictatureBackendDirectory
+from dictature.transformer.aes import AESTransformer
+
+name_transformer = AESTransformer('password1', True)
+value_transformer = AESTransformer('password2', False)
+
+dictionary = Dictature(
+    DictatureBackendSQLite('test_data.sqlite3'),
+    name_transformer=name_transformer,
+    value_transformer=value_transformer
+)
+```

{dictature-0.9.0 → dictature-0.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dictature"
-version = "0.9.0"
+version = "0.9.2"
 description = "dictature -- A generic wrapper around dict-like interface with mulitple backends"
 authors = [
     { name = "Adam Hlavacek", email = "git@adamhlavacek.com" }

{dictature-0.9.0 → dictature-0.9.2}/src/dictature/backend/directory.py

@@ -17,7 +17,8 @@ class DictatureBackendDirectory(DictatureBackendMock):
     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):]
+                # noinspection PyProtectedMember
+                yield DictatureTableDirectory._filename_decode(child.name[len(self.__dir_prefix):], suffix='')
 
     def table(self, name: str) -> 'DictatureTableMock':
         return DictatureTableDirectory(self.__directory, name, self.__dir_prefix)
@@ -25,13 +26,13 @@ class DictatureBackendDirectory(DictatureBackendMock):
 
 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.__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):])
+                yield self._filename_decode(child.name[len(self.__prefix):])
 
     def drop(self) -> None:
         rmtree(self.__path)
@@ -64,16 +65,17 @@ class DictatureTableDirectory(DictatureTableMock):
             self.__item_path(item).unlink()
 
     def __item_path(self, item: str) -> Path:
-        return self.__path / (self.__prefix + self.__filename_encode(item))
+        return self.__path / (self.__prefix + self._filename_encode(item))
 
     @staticmethod
-    def __filename_encode(name: str, suffix: str = '.txt') -> str:
+    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:
+    def _filename_decode(name: str, suffix: str = '.txt') -> str:
+        encoded_name = name[2:-len(suffix) if suffix else len(name)]
         if name.startswith('d_'):
-            return name[2:-5]
-        return bytes.fromhex(name[2:-5]).decode('utf-8')
+            return encoded_name
+        return bytes.fromhex(encoded_name).decode('utf-8')

{dictature-0.9.0 → dictature-0.9.2}/src/dictature/backend/sqlite.py

@@ -17,7 +17,7 @@ class DictatureBackendSQLite(DictatureBackendMock):
         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_%'")
+        tables = self._execute("SELECT tbl_name FROM sqlite_master WHERE type='table' AND tbl_name LIKE 'tb_%'")
         return {table[0][3:] for table in tables}
 
     def table(self, name: str) -> 'DictatureTableMock':

{dictature-0.9.0 → dictature-0.9.2}/src/dictature/dictature.py

@@ -6,15 +6,23 @@ from random import choice
 from typing import Optional, Dict, Any, Set, Iterator, Tuple
 
 from .backend import DictatureBackendMock, ValueMode, Value
+from .transformer import MockTransformer, PassthroughTransformer
 
 
 class Dictature:
-    def __init__(self, backend: DictatureBackendMock) -> None:
-        self.__db = backend
-        self.__db_cache: Dict[str, "DictatureTable"] = {}
+    def __init__(
+            self,
+            backend: DictatureBackendMock,
+            name_transformer: MockTransformer = PassthroughTransformer(),
+            value_transformer: MockTransformer = PassthroughTransformer(),
+    ) -> None:
+        self.__backend = backend
+        self.__table_cache: Dict[str, "DictatureTable"] = {}
+        self.__name_transformer = name_transformer
+        self.__value_transformer = value_transformer
 
     def keys(self) -> Set[str]:
-        return set(self.__db.keys())
+        return set(map(self.__name_transformer.backward, self.__backend.keys()))
 
     def values(self) -> Iterator["DictatureTable"]:
         return map(lambda x: x[1], self.items())
@@ -30,11 +38,16 @@ class Dictature:
         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]
+        if len(self.__table_cache) > 128:
+            del self.__table_cache[choice(list(self.__table_cache.keys()))]
+        if item not in self.__table_cache:
+            self.__table_cache[item] = DictatureTable(
+                self.__backend,
+                item,
+                name_transformer=self.__name_transformer,
+                value_transformer=self.__value_transformer
+            )
+        return self.__table_cache[item]
 
     def __delitem__(self, key: str) -> None:
         self[key].drop()
@@ -47,9 +60,17 @@ class Dictature:
 
 
 class DictatureTable:
-    def __init__(self, db: DictatureBackendMock, table_name: str):
-        self.__db = db
-        self.__table = self.__db.table(table_name)
+    def __init__(
+            self,
+            backend: DictatureBackendMock,
+            table_name: str,
+            name_transformer: MockTransformer = PassthroughTransformer(),
+            value_transformer: MockTransformer = PassthroughTransformer()
+    ):
+        self.__backend = backend
+        self.__name_transformer = name_transformer
+        self.__value_transformer = value_transformer
+        self.__table = self.__backend.table(self.__table_key(table_name))
         self.__table_created = False
 
     def get(self, item: str, default: Optional[Any] = None) -> Any:
@@ -64,7 +85,7 @@ class DictatureTable:
 
     def keys(self) -> Set[str]:
         self.__create_table()
-        return set(self.__table.keys())
+        return set(map(self.__name_transformer.backward, self.__table.keys()))
 
     def values(self) -> Iterator[Any]:
         return map(lambda x: x[1], self.items())
@@ -85,16 +106,17 @@ class DictatureTable:
 
     def __getitem__(self, item: str) -> Any:
         self.__create_table()
-        value = self.__table.get(item)
-        mode = ValueMode(value.mode)
+        saved_value = self.__table.get(self.__item_key(item))
+        mode = ValueMode(saved_value.mode)
+        value = self.__value_transformer.backward(saved_value.value)
         match mode:
             case ValueMode.string:
-                return value.value
+                return value
             case ValueMode.json:
-                return json.loads(value.value)
+                return json.loads(value)
             case ValueMode.pickle:
-                return pickle.loads(decompress(b64decode(value.value.encode('ascii'))))
-        raise ValueError(f"Unknown mode '{value.mode}'")
+                return pickle.loads(decompress(b64decode(value.encode('ascii'))))
+        raise ValueError(f"Unknown mode '{mode}'")
 
     def __setitem__(self, key: str, value: Any) -> None:
         self.__create_table()
@@ -108,10 +130,12 @@ class DictatureTable:
                 value = b64encode(compress(pickle.dumps(value))).decode('ascii')
                 value_mode = value_mode.pickle
 
+        key = self.__item_key(key)
+        value = self.__value_transformer.forward(value)
         self.__table.set(key, Value(value=value, mode=value_mode.value))
 
     def __delitem__(self, key: str) -> None:
-        self.__table.delete(key)
+        self.__table.delete(self.__name_transformer.forward(key))
 
     def __contains__(self, item: str):
         return item in self.keys()
@@ -124,3 +148,17 @@ class DictatureTable:
             return
         self.__table.create()
         self.__table_created = True
+
+    def __item_key(self, item: str) -> str:
+        if not self.__name_transformer.static:
+            for key in self.__table.keys():
+                if self.__name_transformer.backward(key) == item:
+                    return key
+        return self.__name_transformer.forward(item)
+
+    def __table_key(self, table_name: str) -> str:
+        if not self.__name_transformer.static:
+            for key in self.__backend.keys():
+                if self.__name_transformer.backward(key) == table_name:
+                    return key
+        return self.__name_transformer.forward(table_name)

dictature-0.9.2/src/dictature/transformer/__init__.py

@@ -0,0 +1,2 @@
+from .mock import MockTransformer
+from .passthrough import PassthroughTransformer

dictature-0.9.2/src/dictature/transformer/aes.py

@@ -0,0 +1,43 @@
+try:
+    from Crypto.Cipher import AES
+    from Crypto.Util.Padding import pad, unpad
+    from Crypto.Protocol.KDF import scrypt
+except ImportError:
+    raise ImportError("PyCryptodome is required to use this module -- pip install pycryptodome")
+
+from .mock import MockTransformer
+
+
+class AESTransformer(MockTransformer):
+    def __init__(self, passphrase: str, static_names_mode: bool, salt: str = 'dictature') -> None:
+        self.__key = scrypt(passphrase, salt, 16, N=2 ** 14, r=8, p=1)
+        self.__mode = AES.MODE_GCM if not static_names_mode else AES.MODE_ECB
+        self.__static = static_names_mode
+
+    def forward(self, text: str) -> str:
+        cipher = self.__cipher
+        if self.__mode == AES.MODE_GCM:
+            ciphertext, tag = cipher.encrypt_and_digest(pad(text.encode('utf8'), AES.block_size))
+            return (cipher.nonce + tag + ciphertext).hex()
+        else:
+            return cipher.encrypt(pad(text.encode('utf8'), AES.block_size)).hex()
+
+    def backward(self, text: str) -> str:
+        data = bytes.fromhex(text)
+        cipher = self.__cipher
+        if self.__mode == AES.MODE_GCM:
+            nonce, tag, ciphertext = data[:16], data[16:32], data[32:]
+            # noinspection PyTypeChecker
+            cipher = AES.new(self.__key, self.__mode, nonce=nonce)
+            return unpad(cipher.decrypt_and_verify(ciphertext, tag), AES.block_size).decode('utf8')
+        else:
+            return unpad(cipher.decrypt(data), AES.block_size).decode('utf8')
+
+    @property
+    def __cipher(self) -> AES:
+        # noinspection PyTypeChecker
+        return AES.new(self.__key, self.__mode)
+
+    @property
+    def static(self) -> bool:
+        return self.__static

dictature-0.9.2/src/dictature/transformer/mock.py

@@ -0,0 +1,9 @@
+
+class MockTransformer:
+    def forward(self, text: str) -> str:
+        raise NotImplementedError("This method should be implemented by the child class")
+    def backward(self, text: str) -> str:
+        raise NotImplementedError("This method should be implemented by the child class")
+    @property
+    def static(self) -> bool:
+        raise NotImplementedError("This method should be implemented by the child class")

dictature-0.9.2/src/dictature/transformer/passthrough.py

@@ -0,0 +1,10 @@
+from .mock import MockTransformer
+
+class PassthroughTransformer(MockTransformer):
+    def forward(self, text: str) -> str:
+        return text
+    def backward(self, text: str) -> str:
+        return text
+    @property
+    def static(self) -> bool:
+        return True

{dictature-0.9.0 → dictature-0.9.2/src/dictature.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dictature
-Version: 0.9.0
+Version: 0.9.2
 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
@@ -11,7 +11,7 @@ Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-# SQLiDictature
+# Dictature
 
 A wrapper for Python's dictionary with multiple backends.
 
@@ -22,7 +22,7 @@ pip install dictature
 ```
 
 ## Dictature usage
-This package also includes a class that allows you to use your SQLite db as a Python dictionary:
+This package also includes a class that allows you to use your SQLite db or any backend as a Python dictionary:
 
 ```python
 from dictature import Dictature
@@ -49,3 +49,27 @@ print(dictionary['test']['thread'])  # prints <class 'threading.Thread'>
 del dictionary['test']['list']  # deletes the record
 del dictionary['test']  # drops whole table
 ```
+
+Currently, the following backends are supported:
+- `DictatureBackendDirectory`: stores the data in a directory as json files
+- `DictatureBackendSQLite`: stores the data in a SQLite database
+
+### Transformers
+
+You can also use transformers to change how the values are stored. E.g. to encrypt data, you can use the
+`AESTransformer` (which requires the `pycryptodome` package):
+
+```python
+from dictature import Dictature
+from dictature.backend import DictatureBackendDirectory
+from dictature.transformer.aes import AESTransformer
+
+name_transformer = AESTransformer('password1', True)
+value_transformer = AESTransformer('password2', False)
+
+dictionary = Dictature(
+    DictatureBackendSQLite('test_data.sqlite3'),
+    name_transformer=name_transformer,
+    value_transformer=value_transformer
+)
+```

{dictature-0.9.0 → dictature-0.9.2}/src/dictature.egg-info/SOURCES.txt

@@ -10,4 +10,8 @@ src/dictature.egg-info/top_level.txt
 src/dictature/backend/__init__.py
 src/dictature/backend/directory.py
 src/dictature/backend/mock.py
-src/dictature/backend/sqlite.py
+src/dictature/backend/sqlite.py
+src/dictature/transformer/__init__.py
+src/dictature/transformer/aes.py
+src/dictature/transformer/mock.py
+src/dictature/transformer/passthrough.py