dictature 0.9.2__tar.gz → 0.9.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dictature
-Version: 0.9.2
+Version: 0.9.3
 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

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

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

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

@@ -71,7 +71,8 @@ class DictatureTableDirectory(DictatureTableMock):
     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}'
+        name = name.encode('utf-8').hex()
+        return f'e_{name}{suffix}'
 
     @staticmethod
     def _filename_decode(name: str, suffix: str = '.txt') -> str:

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

@@ -15,11 +15,13 @@ class Dictature:
             backend: DictatureBackendMock,
             name_transformer: MockTransformer = PassthroughTransformer(),
             value_transformer: MockTransformer = PassthroughTransformer(),
+            table_name_transformer: Optional[MockTransformer] = None,
     ) -> None:
         self.__backend = backend
         self.__table_cache: Dict[str, "DictatureTable"] = {}
         self.__name_transformer = name_transformer
         self.__value_transformer = value_transformer
+        self.__table_name_transformer = table_name_transformer or name_transformer
 
     def keys(self) -> Set[str]:
         return set(map(self.__name_transformer.backward, self.__backend.keys()))
@@ -109,13 +111,12 @@ class DictatureTable:
         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
-            case ValueMode.json:
-                return json.loads(value)
-            case ValueMode.pickle:
-                return pickle.loads(decompress(b64decode(value.encode('ascii'))))
+        if mode == ValueMode.string:
+            return value
+        elif mode == ValueMode.json:
+            return json.loads(value)
+        elif mode == ValueMode.pickle:
+            return pickle.loads(decompress(b64decode(value.encode('ascii'))))
         raise ValueError(f"Unknown mode '{mode}'")
 
     def __setitem__(self, key: str, value: Any) -> None:
@@ -135,7 +136,7 @@ class DictatureTable:
         self.__table.set(key, Value(value=value, mode=value_mode.value))
 
     def __delitem__(self, key: str) -> None:
-        self.__table.delete(self.__name_transformer.forward(key))
+        self.__table.delete(self.__item_key(key))
 
     def __contains__(self, item: str):
         return item in self.keys()

{dictature-0.9.2 → dictature-0.9.3}/src/dictature/transformer/__init__.py

@@ -1,2 +1,3 @@
 from .mock import MockTransformer
 from .passthrough import PassthroughTransformer
+from .pipeline import PipelineTransformer

{dictature-0.9.2 → dictature-0.9.3}/src/dictature/transformer/aes.py

@@ -15,7 +15,7 @@ class AESTransformer(MockTransformer):
         self.__static = static_names_mode
 
     def forward(self, text: str) -> str:
-        cipher = self.__cipher
+        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()
@@ -24,19 +24,15 @@ class AESTransformer(MockTransformer):
 
     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')
+            return unpad(self.__cipher(nonce=nonce).decrypt_and_verify(ciphertext, tag), AES.block_size).decode('utf8')
         else:
-            return unpad(cipher.decrypt(data), AES.block_size).decode('utf8')
+            return unpad(self.__cipher().decrypt(data), AES.block_size).decode('utf8')
 
-    @property
-    def __cipher(self) -> AES:
+    def __cipher(self, **kwargs) -> AES:
         # noinspection PyTypeChecker
-        return AES.new(self.__key, self.__mode)
+        return AES.new(self.__key, self.__mode, **kwargs)
 
     @property
     def static(self) -> bool:

dictature-0.9.3/src/dictature/transformer/hmac.py

@@ -0,0 +1,24 @@
+import hmac
+from hashlib import sha256
+from .mock import MockTransformer
+
+
+class HmacTransformer(MockTransformer):
+    def __init__(self, secret: str = 'dictature') -> None:
+        self.__secret = secret
+
+    def forward(self, text: str) -> str:
+        return f"{self.__hmac(text)}-{text}"
+
+    def backward(self, text: str) -> str:
+        mac, text = text.split('-', 1)
+        if mac != self.__hmac(text):
+            raise ValueError('Invalid HMAC')
+        return text
+
+    def __hmac(self, text: str) -> str:
+        return hmac.new(self.__secret.encode('utf8'), text.encode('utf8'), sha256).hexdigest()
+
+    @property
+    def static(self) -> bool:
+        return True

dictature-0.9.3/src/dictature/transformer/pipeline.py

@@ -0,0 +1,22 @@
+from typing import List
+
+from .mock import MockTransformer
+
+
+class PipelineTransformer(MockTransformer):
+    def __init__(self, transformers: List[MockTransformer]) -> None:
+        self.__transformers = transformers
+
+    def forward(self, text: str) -> str:
+        for transformer in self.__transformers:
+            text = transformer.forward(text)
+        return text
+
+    def backward(self, text: str) -> str:
+        for transformer in reversed(self.__transformers):
+            text = transformer.backward(text)
+        return text
+
+    @property
+    def static(self) -> bool:
+        return all(t.static for t in self.__transformers)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dictature
-Version: 0.9.2
+Version: 0.9.3
 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

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

@@ -13,5 +13,8 @@ src/dictature/backend/mock.py
 src/dictature/backend/sqlite.py
 src/dictature/transformer/__init__.py
 src/dictature/transformer/aes.py
+src/dictature/transformer/hmac.py
 src/dictature/transformer/mock.py
-src/dictature/transformer/passthrough.py
+src/dictature/transformer/passthrough.py
+src/dictature/transformer/pipeline.py
+tests/test_operations.py

dictature-0.9.3/tests/test_operations.py

@@ -0,0 +1,126 @@
+import unittest
+from itertools import product
+from typing import NamedTuple, Optional
+from tempfile import mkdtemp, mktemp
+
+from parameterized import parameterized
+
+from src.dictature import Dictature
+from src.dictature.backend.mock import DictatureBackendMock
+from src.dictature.backend.sqlite import DictatureBackendSQLite
+from src.dictature.backend.directory import DictatureBackendDirectory
+from src.dictature.transformer import PassthroughTransformer, PipelineTransformer
+from src.dictature.transformer.mock import MockTransformer
+from src.dictature.transformer.aes import AESTransformer
+from src.dictature.transformer.hmac import HmacTransformer
+
+
+BACKENDS = [
+    DictatureBackendDirectory(mkdtemp(prefix='dictature')),
+    DictatureBackendSQLite(mktemp(prefix='dictature', suffix='.sqlite3')),
+]
+
+TRANSFORMERS = [
+    PassthroughTransformer(),
+    AESTransformer('password', False),
+    AESTransformer('password', True),
+    HmacTransformer(),
+    HmacTransformer('password'),
+    PipelineTransformer([HmacTransformer(), AESTransformer('password', False)]),
+]
+
+
+class Settings(NamedTuple):
+    backend: DictatureBackendMock
+    name_transformer: MockTransformer
+    value_transformer: MockTransformer
+    table_name_transformer: Optional[MockTransformer]
+
+
+SETTINGS = [
+    (Settings(backend, name_transformer, value_transformer, table_name_transformer),)
+    for backend, name_transformer, value_transformer, table_name_transformer in product(BACKENDS, TRANSFORMERS, TRANSFORMERS, [*TRANSFORMERS, None])
+]
+
+
+class TestOperations(unittest.TestCase):
+    def setUp(self):
+        self.backend = None
+
+    def tearDown(self):
+        if self.backend:
+            for table in self.backend.keys():
+                del self.backend[table]
+
+    @parameterized.expand(SETTINGS)
+    def test_basic_set_and_get(self, settings: Settings):
+        self.backend = Dictature(
+            backend=settings.backend,
+            name_transformer=settings.name_transformer,
+            value_transformer=settings.value_transformer,
+            table_name_transformer=settings.table_name_transformer
+        )
+        table = self.backend['table']
+        table['key'] = 'value'
+        table['key2'] = 'value2'
+        table['key'] = 'value3'
+        self.backend['table2']['key'] = 'value'
+        self.assertEqual(table['key'], 'value3')
+        self.assertEqual(table.keys(), {'key', 'key2'})
+        self.assertEqual(self.backend.keys(), {'table', 'table2'})
+
+    @parameterized.expand(SETTINGS)
+    def test_saving_json_value(self, settings: Settings):
+        self.backend = Dictature(
+            backend=settings.backend,
+            name_transformer=settings.name_transformer,
+            value_transformer=settings.value_transformer,
+            table_name_transformer=settings.table_name_transformer
+        )
+        value = {'key': 'value'}
+        self.backend['table']['key'] = value
+        self.assertDictEqual(self.backend['table']['key'], value)
+        self.backend['table']['key'] = 2
+        self.assertEqual(self.backend['table']['key'], 2)
+
+    @parameterized.expand(SETTINGS)
+    def test_saving_pickle_value(self, settings: Settings):
+        self.backend = Dictature(
+            backend=settings.backend,
+            name_transformer=settings.name_transformer,
+            value_transformer=settings.value_transformer,
+            table_name_transformer=settings.table_name_transformer
+        )
+        self.backend['table']['key'] = NamedTuple
+        self.assertEqual(self.backend['table']['key'], NamedTuple)
+
+    @parameterized.expand(SETTINGS)
+    def test_deletion_of_table_key(self, settings: Settings):
+        self.backend = Dictature(
+            backend=settings.backend,
+            name_transformer=settings.name_transformer,
+            value_transformer=settings.value_transformer,
+            table_name_transformer=settings.table_name_transformer
+        )
+        table = self.backend['table']
+        table['key'] = 'value'
+        table['key2'] = 'value2'
+        del table['key']
+        self.assertEqual({'key2'}, table.keys())
+
+    @parameterized.expand(SETTINGS)
+    def test_deletion_of_whole_table(self, settings: Settings):
+        self.backend = Dictature(
+            backend=settings.backend,
+            name_transformer=settings.name_transformer,
+            value_transformer=settings.value_transformer,
+            table_name_transformer=settings.table_name_transformer
+        )
+        self.backend['table2']['key'] = 'value'
+        self.backend['table']['key'] = 'value'
+        del self.backend['table']
+        self.assertEqual(self.backend.keys(), {'table2'})
+
+
+if __name__ == '__main__':
+    unittest.main()