dictature 0.9.4__py3-none-any.whl → 0.9.6__py3-none-any.whl

dictature/backend/directory.py

@@ -1,14 +1,12 @@
-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
+from .mock import DictatureTableMock, DictatureBackendMock, Value, ValueMode, ValueSerializer, ValueSerializerMode
 
 
 class DictatureBackendDirectory(DictatureBackendMock):
-    def __init__(self, directory: Union[Path, str], dir_prefix: str = 'db_') -> None:
+    def __init__(self, directory: Union[Path, str], dir_prefix: str = 'db_', item_prefix: str = 'item_') -> None:
         """
         Create a new directory backend
         :param directory: directory to store the data
@@ -18,6 +16,7 @@ class DictatureBackendDirectory(DictatureBackendMock):
             directory = Path(directory)
         self.__directory = directory
         self.__dir_prefix = dir_prefix
+        self.__item_prefix = item_prefix
 
     def keys(self) -> Iterable[str]:
         for child in self.__directory.iterdir():
@@ -26,13 +25,14 @@ class DictatureBackendDirectory(DictatureBackendMock):
                 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)
+        return DictatureTableDirectory(self.__directory, name, self.__dir_prefix, self.__item_prefix)
 
 
 class DictatureTableDirectory(DictatureTableMock):
-    def __init__(self, path_root: Path, name: str, db_prefix: str, prefix: str = 'item_') -> None:
+    def __init__(self, path_root: Path, name: str, db_prefix: str, prefix: str) -> None:
         self.__path = path_root / (db_prefix + self._filename_encode(name, suffix=''))
         self.__prefix = prefix
+        self.__serializer = ValueSerializer(mode=ValueSerializerMode.filename_only)
 
     def keys(self) -> Iterable[str]:
         for child in self.__path.iterdir():
@@ -49,8 +49,7 @@ class DictatureTableDirectory(DictatureTableMock):
         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
+        save_data = self.__serializer.serialize(value)
 
         file_target_tmp.write_text(save_data)
         file_target_tmp.rename(file_target)
@@ -58,10 +57,7 @@ class DictatureTableDirectory(DictatureTableMock):
     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)
+            return self.__serializer.deserialize(save_data)
         except FileNotFoundError:
             raise KeyError(item)
 
@@ -74,14 +70,13 @@ class DictatureTableDirectory(DictatureTableMock):
 
     @staticmethod
     def _filename_encode(name: str, suffix: str = '.txt') -> str:
-        if name == sub(r'[^\w_. -]', '_', name):
-            return f"d_{name}{suffix}"
-        name = name.encode('utf-8').hex()
-        return f'e_{name}{suffix}'
+        return ValueSerializer(mode=ValueSerializerMode.filename_only).serialize(Value(
+            value=name,
+            mode=ValueMode.string.value
+        )) + suffix
 
     @staticmethod
     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 encoded_name
-        return bytes.fromhex(encoded_name).decode('utf-8')
+        if suffix:
+            name = name[:-len(suffix)]
+        return ValueSerializer(mode=ValueSerializerMode.filename_only).deserialize(name).value

dictature/backend/misp.py

@@ -1,8 +1,6 @@
-from json import dumps, loads
-from re import sub
 from typing import Iterable, Optional
 
-from .mock import DictatureTableMock, DictatureBackendMock, Value, ValueMode
+from .mock import DictatureTableMock, DictatureBackendMock, Value, ValueMode, ValueSerializer, ValueSerializerMode
 
 try:
     from pymisp import PyMISP, MISPEvent, MISPAttribute
@@ -39,6 +37,7 @@ class DictatureTableMISP(DictatureTableMock):
         self.__event_description = event_description
         self.__tag = tag
         self.__event: Optional[MISPEvent] = None
+        self.__serializer = ValueSerializer(mode=ValueSerializerMode.ascii_only)
 
     def keys(self) -> Iterable[str]:
         for attribute in self.__event_attributes():
@@ -51,18 +50,18 @@ class DictatureTableMISP(DictatureTableMock):
         self.__get_event()
 
     def set(self, item: str, value: Value) -> None:
-        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
+        item_name = self.__serializer.serialize(Value(value=item, mode=ValueMode.string.value))
+        save_data = self.__serializer.serialize(value)
 
         for attribute in self.__event_attributes():
-            if attribute.value == item:
-                attribute.value = item
+            if attribute.value == item_name:
+                attribute.value = item_name
                 attribute.comment = save_data
                 self.__misp.update_attribute(attribute)
                 break
         else:
             attribute = MISPAttribute()
-            attribute.value = item
+            attribute.value = item_name
             attribute.comment = save_data
             attribute.type = 'comment'
             attribute.to_ids = False
@@ -71,12 +70,10 @@ class DictatureTableMISP(DictatureTableMock):
             self.__get_event().attributes.append(attribute)
 
     def get(self, item: str) -> Value:
+        item_name = self.__serializer.serialize(Value(value=item, mode=ValueMode.string.value))
         for attribute in self.__event_attributes():
-            if attribute.value == item:
-                if attribute.comment.startswith('{'):
-                    data = loads(attribute.comment)
-                    return Value(data['value'], data['mode'])
-                return Value(attribute.comment, ValueMode.string.value)
+            if attribute.value == item_name:
+                return self.__serializer.deserialize(attribute.comment)
         raise KeyError(item)
 
     def delete(self, item: str) -> None:
@@ -110,17 +107,3 @@ class DictatureTableMISP(DictatureTableMock):
             if attribute.type != 'comment' or (hasattr(attribute, 'deleted') and attribute.deleted):
                 continue
             yield attribute
-
-    @staticmethod
-    def _record_encode(name: str, suffix: str = '.txt') -> str:
-        if name == sub(r'[^\w_. -]', '_', name):
-            return f"d_{name}{suffix}"
-        name = name.encode('utf-8').hex()
-        return f'e_{name}{suffix}'
-
-    @staticmethod
-    def _record_decode(name: str, suffix: str = '.txt') -> str:
-        encoded_name = name[2:-len(suffix) if suffix else len(name)]
-        if name.startswith('d_'):
-            return encoded_name
-        return bytes.fromhex(encoded_name).decode('utf-8')

dictature/backend/mock.py

@@ -1,3 +1,5 @@
+from json import dumps, loads
+from string import hexdigits, ascii_letters, digits, printable
 from typing import Iterable, NamedTuple
 from enum import Enum
 
@@ -13,6 +15,84 @@ class Value(NamedTuple):
     mode: int
 
 
+class ValueSerializerMode(Enum):
+    any_string = 0
+    ascii_only = 1
+    filename_only = 2
+    hex_only = 3
+
+
+class ValueSerializer:
+    prefix = 'a09e'
+
+    def __init__(self, mode: ValueSerializerMode = ValueSerializerMode.any_string):
+        self.__mode = mode
+
+    def deserialize(self, serialized: str) -> Value:
+        """
+        Deserialize a string into a Value object
+        :param serialized: serialized string
+        :return: Value object
+        """
+        # Check if the string starts with the prefix (hex-encoded)
+        if serialized.startswith(self.prefix):
+            # Decode the hex part
+            hex_data = serialized[len(self.prefix):]
+            decoded = bytes.fromhex(hex_data).decode('ascii')
+            # Recursively deserialize the decoded string
+            return ValueSerializer(mode=ValueSerializerMode.ascii_only).deserialize(decoded)
+
+        # Check if the string looks like JSON
+        if serialized.startswith('{'):
+            try:
+                data = loads(serialized)
+                return Value(value=data['value'], mode=data['mode'])
+            except (ValueError, KeyError):
+                pass  # Not valid JSON or missing required keys
+
+        # Direct value (string mode)
+        return Value(value=serialized, mode=ValueMode.string.value)
+
+    def serialize(self, value: Value) -> str:
+        """
+        Serializes a `Value` object into a `str`, converting its data representation
+        based on the serialization mode set in `ValueSerializerMode`. Depending on
+        the mode provided, the object can be serialized directly if its string
+        representation conforms to certain criteria, or it may be converted into
+        a JSON format. Handles customization of allowed characters and uses prefix
+        to encode conditions if the direct representation is not permitted.
+
+        If the mode is incompatible or unsupported, raises a `NotImplementedError`.
+
+        :param value: Instance of `Value` to be serialized.
+
+        :return: Serialized representation of the `Value` object as a string.
+
+        :raises NotImplementedError: If the mode provided in `ValueSerializerMode`
+            is unsupported.
+        """
+        if self.__mode == ValueSerializerMode.hex_only:
+            allowed_chars = hexdigits
+        elif self.__mode == ValueSerializerMode.filename_only:
+            allowed_chars = ascii_letters + digits + '_.'
+        elif self.__mode in (ValueSerializerMode.any_string, ValueSerializerMode.ascii_only):
+            allowed_chars = None
+        else:
+            raise NotImplementedError(self.__mode)
+
+        if allowed_chars is not None:
+            # Only a subset of characters is allowed if all match and do not start with the reserved prefix, encode directly
+            if value.mode == ValueMode.string.value and all(map(lambda x: x in allowed_chars, value.value)) and not value.value.startswith(self.prefix):
+                return value.value
+            return self.prefix + ValueSerializer(mode=ValueSerializerMode.ascii_only).serialize(value).encode('ascii').hex()
+
+        # Save as JSON if not string or value is starting with { (indicating JSON)
+        save_as_json = value.mode != ValueMode.string.value or value.value.startswith('{') or value.value.startswith(self.prefix)
+        # Save as JSON if only ASCII strings are allowed
+        save_as_json = save_as_json or (self.__mode == ValueSerializerMode.ascii_only and any(filter(lambda x: x not in printable, value.value)))
+        return dumps({'value': value.value, 'mode': value.mode}, indent=1) if save_as_json else value.value
+
+
 class DictatureBackendMock:
     def keys(self) -> Iterable[str]:
         """
@@ -76,4 +156,4 @@ class DictatureTableMock:
         :param item: key to delete
         :return: None
         """
-        raise NotImplementedError("This method should be implemented by the subclass")
+        raise NotImplementedError("This method should be implemented by the subclass")

dictature/dictature.py

@@ -221,19 +221,19 @@ class DictatureTable:
         :return: None
         """
         self.__create_table()
-        value_mode = ValueMode.string
+        value_mode: int = ValueMode.string.value
 
         if type(value) is not str:
             try:
                 value = json.dumps(value)
-                value_mode = ValueMode.json
+                value_mode = ValueMode.json.value
             except TypeError:
                 value = b64encode(compress(pickle.dumps(value))).decode('ascii')
-                value_mode = value_mode.pickle
+                value_mode = ValueMode.pickle.value
 
         key = self.__item_key(key)
         value = self.__value_transformer.forward(value)
-        self.__table.set(key, Value(value=value, mode=value_mode.value))
+        self.__table.set(key, Value(value=value, mode=value_mode))
 
     def __delitem__(self, key: str) -> None:
         """

dictature/transformer/gzip.py

@@ -0,0 +1,53 @@
+import gzip
+import base64
+
+from .mock import MockTransformer
+
+
+class GzipTransformer(MockTransformer):
+    """
+    Compresses and decompresses text using Gzip.
+
+    The compressed data is Base64 encoded to ensure it can be represented as a string.
+    """
+    def __init__(self) -> None:
+        """
+        Initializes the GzipTransformer. No parameters needed for basic Gzip.
+        """
+        # No specific state needed for standard gzip compression/decompression
+        pass
+
+    def forward(self, text: str) -> str:
+        """
+        Compresses the input text using Gzip and returns a Base64 encoded string.
+        :param text: The original text string.
+        :return: A Base64 encoded string representing the Gzipped data.
+        """
+        byte_data = text.encode('utf-8')
+        compressed_bytes = gzip.compress(byte_data)
+        base64_bytes = base64.b64encode(compressed_bytes)
+        base64_string = base64_bytes.decode('ascii')
+        return base64_string
+
+    def backward(self, text: str) -> str:
+        """
+        Decompresses the Base64 encoded Gzip data back into the original text.
+        :param text: A Base64 encoded string representing Gzipped data.
+        :return: The original text string.
+        :raises ValueError: If the input string is not valid Base64 or not valid Gzip data.
+        """
+        try:
+            base64_bytes = text.encode('ascii')
+            compressed_bytes = base64.b64decode(base64_bytes)
+            original_bytes = gzip.decompress(compressed_bytes)
+            original_text = original_bytes.decode('utf-8')
+            return original_text
+        except (gzip.BadGzipFile, UnicodeDecodeError) as e:
+            # Catch errors related to Base64 decoding, Gzip decompression, or UTF-8 decoding
+            raise ValueError(f"Invalid input data for Gzip decompression: {e}") from e
+
+    @property
+    def static(self) -> bool:
+        return False
+
+

{dictature-0.9.4.dist-info → dictature-0.9.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dictature
-Version: 0.9.4
+Version: 0.9.6
 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
@@ -78,5 +78,6 @@ dictionary = Dictature(
 Currently, the following transformers are supported:
 - `AESTransformer`: encrypts/decrypts the data using AES
 - `HmacTransformer`: signs the data using HMAC or performs hash integrity checks
+- `GzipTransformer`: compresses given data
 - `PassthroughTransformer`: does nothing
 - `PipelineTransformer`: chains multiple transformers

{dictature-0.9.4.dist-info → dictature-0.9.6.dist-info}/RECORD

@@ -1,18 +1,19 @@
 dictature/__init__.py,sha256=UCPJKHeyirRZ0pCYoyeat-rwXa8pDezOJ3UWCipDdyc,33
-dictature/dictature.py,sha256=VM4RcXftQl2cFY8GxsRl7h3K8tsH7urNoT7GyGsxGuo,9314
+dictature/dictature.py,sha256=SHwG_XvGwm6qpvMt5OjeS8BoU5wLgJi_4jIBKFmYFyI,9330
 dictature/backend/__init__.py,sha256=d5s6QCJOUzFglVNg8Cqqx_8b61S-AOTGjEUIF6FS69U,149
-dictature/backend/directory.py,sha256=Wf6dtllkqVA70DsnFoFzEHi_-RrTeOwqX5TFU-mYjrk,3451
-dictature/backend/misp.py,sha256=ZT392TkAkoP1fB5ZXjArD1Vsm00hvvq08msCv6QXbh8,4971
-dictature/backend/mock.py,sha256=Bllai6uZ1cRL8mKLbB3YQQo26mxTFepqzGu3FfOL1d4,2183
+dictature/backend/directory.py,sha256=YuwZbWxVKOuL_Aup-EHyK96MXLaD91xzIaXj6nv5WpA,3280
+dictature/backend/misp.py,sha256=iPjvgnJg6WveNP2wvgN7OK2vkX-SC9qYPrdoa9ahRT0,4411
+dictature/backend/mock.py,sha256=BzfLstxkTIjk6mcMTdFKj8rSaFgIqn9-2Cyelslj8bY,5889
 dictature/backend/sqlite.py,sha256=zyphYEeLY4eGuBCor16i80_-brdipMpXZ3_kONwErsE,5237
 dictature/transformer/__init__.py,sha256=JIFJpXU6iB9hIUM8L7HL2o9Nqjm_YbMEuQBQC8ZJ6b4,124
 dictature/transformer/aes.py,sha256=ZhC1dT9QpnziErkDLriWLgXDEFNGQW0KG4aqSN2AZpA,1926
+dictature/transformer/gzip.py,sha256=pngvJQeALa-lv98VBeJ1Pl6_gaAfGcPXD9UR7PexrYA,1921
 dictature/transformer/hmac.py,sha256=vURsB0HlzRPn_Vkl7lGmZV9OKempQuds8AanmadDxIo,834
 dictature/transformer/mock.py,sha256=7zu65ZqUV_AVRaPSzNd73cVMXixXt31SeuX9OKZxaJQ,948
 dictature/transformer/passthrough.py,sha256=Pt3N6G_Qh6HJ_q75ETL5nfAwYHLB-SjkVwUwbbbMik8,344
 dictature/transformer/pipeline.py,sha256=OaQaJeJ5NpICetJe08r8ontqstsXGuW8jDbKw1zxYs4,842
-dictature-0.9.4.dist-info/LICENSE,sha256=n1U9DKr8sM5EY2QHcvxSGiKTDWUT8MyXsOC79w94MT0,1072
-dictature-0.9.4.dist-info/METADATA,sha256=QklI5x9PnsuJZ-6jIcFskCDxSVveI3le5IJSIh_8E4Q,2826
-dictature-0.9.4.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-dictature-0.9.4.dist-info/top_level.txt,sha256=-RO39WWCF44lqiXhSUcACVqbk6SkgReZTz7ZmHKH3-U,10
-dictature-0.9.4.dist-info/RECORD,,
+dictature-0.9.6.dist-info/LICENSE,sha256=n1U9DKr8sM5EY2QHcvxSGiKTDWUT8MyXsOC79w94MT0,1072
+dictature-0.9.6.dist-info/METADATA,sha256=46tXjvOFmBe0AxHyBr-DYMteFN2TVWcXFHa-YMdfJlw,2869
+dictature-0.9.6.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+dictature-0.9.6.dist-info/top_level.txt,sha256=-RO39WWCF44lqiXhSUcACVqbk6SkgReZTz7ZmHKH3-U,10
+dictature-0.9.6.dist-info/RECORD,,

{dictature-0.9.4.dist-info → dictature-0.9.6.dist-info}/WHEEL

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