dictature 0.9.4__tar.gz → 0.9.5__tar.gz

{dictature-0.9.4/src/dictature.egg-info → dictature-0.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dictature
-Version: 0.9.4
+Version: 0.9.5
 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.4 → dictature-0.9.5}/pyproject.toml

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

{dictature-0.9.4 → dictature-0.9.5}/src/dictature/backend/directory.py

@@ -1,10 +1,8 @@
-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):
@@ -33,6 +31,7 @@ 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
+        self.__serializer = ValueSerializer(mode=ValueSerializerMode.filename_only)
 
     def keys(self) -> Iterable[str]:
         for child in self.__path.iterdir():
@@ -49,8 +48,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 +56,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 +69,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-0.9.4 → dictature-0.9.5}/src/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-0.9.5/src/dictature/backend/mock.py

@@ -0,0 +1,159 @@
+from json import dumps, loads
+from string import hexdigits, ascii_letters, digits, printable
+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 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]:
+        """
+        Return all table names
+        :return: all table names
+        """
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def table(self, name: str) -> 'DictatureTableMock':
+        """
+        Create a table object based on the name
+        :param name: name of the table
+        :return: table object
+        """
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+
+class DictatureTableMock:
+    def keys(self) -> Iterable[str]:
+        """
+        Return all keys in the table
+        :return: all keys in the table
+        """
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def drop(self) -> None:
+        """
+        Delete the table
+        :return: None
+        """
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def create(self) -> None:
+        """
+        Create the table in the backend
+        :return: None
+        """
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def set(self, item: str, value: Value) -> None:
+        """
+        Set a value in the table
+        :param item: key to set
+        :param value: value to set
+        :return: None
+        """
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def get(self, item: str) -> Value:
+        """
+        Get a value from the table
+        :param item: key to get
+        :return: value
+        :raises KeyError: if the key does not exist
+        """
+        raise NotImplementedError("This method should be implemented by the subclass")
+
+    def delete(self, item: str) -> None:
+        """
+        Delete a value from the table
+        :param item: key to delete
+        :return: None
+        """
+        raise NotImplementedError("This method should be implemented by the subclass")

{dictature-0.9.4 → dictature-0.9.5}/src/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-0.9.4 → dictature-0.9.5/src/dictature.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dictature
-Version: 0.9.4
+Version: 0.9.5
 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.4/src/dictature/backend/mock.py

@@ -1,79 +0,0 @@
-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]:
-        """
-        Return all table names
-        :return: all table names
-        """
-        raise NotImplementedError("This method should be implemented by the subclass")
-
-    def table(self, name: str) -> 'DictatureTableMock':
-        """
-        Create a table object based on the name
-        :param name: name of the table
-        :return: table object
-        """
-        raise NotImplementedError("This method should be implemented by the subclass")
-
-
-class DictatureTableMock:
-    def keys(self) -> Iterable[str]:
-        """
-        Return all keys in the table
-        :return: all keys in the table
-        """
-        raise NotImplementedError("This method should be implemented by the subclass")
-
-    def drop(self) -> None:
-        """
-        Delete the table
-        :return: None
-        """
-        raise NotImplementedError("This method should be implemented by the subclass")
-
-    def create(self) -> None:
-        """
-        Create the table in the backend
-        :return: None
-        """
-        raise NotImplementedError("This method should be implemented by the subclass")
-
-    def set(self, item: str, value: Value) -> None:
-        """
-        Set a value in the table
-        :param item: key to set
-        :param value: value to set
-        :return: None
-        """
-        raise NotImplementedError("This method should be implemented by the subclass")
-
-    def get(self, item: str) -> Value:
-        """
-        Get a value from the table
-        :param item: key to get
-        :return: value
-        :raises KeyError: if the key does not exist
-        """
-        raise NotImplementedError("This method should be implemented by the subclass")
-
-    def delete(self, item: str) -> None:
-        """
-        Delete a value from the table
-        :param item: key to delete
-        :return: None
-        """
-        raise NotImplementedError("This method should be implemented by the subclass")