datavalue 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

datavalue/classes/complex_data.py

@@ -2,6 +2,7 @@
 from typing import Type, Optional, Any, Iterable
 from .. import exceptions
 from .primitive_data import PrimitiveData
+import json
 
 # Classes definition
 class ComplexData:
@@ -95,7 +96,134 @@ class ComplexData:
 
         return True
         
+    @classmethod
+    def _serialize_recursive(cls, element: Any) -> Any:
+        # 1. Caso: Instancias de tus clases
+        if isinstance(element, (PrimitiveData, ComplexData)):
+            return {
+                "__type__": element.__class__.__name__,
+                "content": element.to_dict()
+            }
+        
+        # 2. Caso: Tipos de datos (clases como str, int, dict)
+        if isinstance(element, type):
+            return {"__class__": element.__name__}
+        
+        # 3. Caso: Colecciones estándar (recursión profunda)
+        if isinstance(element, (list, tuple, set, frozenset)):
+            return [cls._serialize_recursive(i) for i in element]
+        
+        if isinstance(element, dict):
+            return {str(k): cls._serialize_recursive(v) for k, v in element.items()}
+        
+        # 4. Caso: Literales serializables (int, str, float, bool, None)
+        return element
+
+    @classmethod
+    def _deserialize_recursive(cls, element: Any) -> Any:
+        SAFE_TYPES = {
+            "list": list, "tuple": tuple, "set": set, "frozenset": frozenset, 
+            "dict": dict, "str": str, "int": int, "float": float, "bool": bool,
+            "bytes": bytes, "bytearray": bytearray
+        }
+
+        # A. Manejo de Diccionarios (Estructuras u Objetos Serializados)
+        if isinstance(element, dict):
+            # Caso 1: Es un objeto serializado (PrimitiveData o ComplexData)
+            if "__type__" in element:
+                obj_type = element["__type__"]
+                content = element["content"]
+                
+                if obj_type == "PrimitiveData":
+                    return PrimitiveData.from_dict(content)
+                elif obj_type == "ComplexData":
+                    return cls.from_dict(content)
+                else:
+                    raise ValueError(f"Unknown serialized object type: {obj_type}")
+
+            # Caso 2: Es una referencia a un tipo de clase (__class__)
+            if "__class__" in element:
+                type_name = element["__class__"]
+                if type_name in SAFE_TYPES:
+                    return SAFE_TYPES[type_name]
+                raise ValueError(f"Type '{type_name}' is not allowed or unknown.")
+
+            # Caso 3: Es un diccionario de datos común (recurse keys & values)
+            return {k: cls._deserialize_recursive(v) for k, v in element.items()}
+
+        # B. Manejo de Listas (recurse items)
+        if isinstance(element, list):
+            return [cls._deserialize_recursive(item) for item in element]
+        
+        # C. Literales (retorno directo)
+        return element
+
+
     # Public methods
+    def to_dict(self) -> dict:
+        return {
+            "DATA_TYPE":self.data_type.__name__ if hasattr(self.data_type, '__name__') else str(self.data_type),
+            "VALUE":self._serialize_recursive(self.value),
+            "MAXIMUM_LENGTH":self.maximum_length,
+            "MINIMUM_LENGTH":self.minimum_length,
+            "POSSIBLE_VALUES":self._serialize_recursive(self.possible_values) if self.possible_values is not None else None,
+            "DATA_CLASS":self.data_class,
+            "__type__":"ComplexData"
+        }
+
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> 'ComplexData':
+        # 1. Secure types mapping
+        SAFE_TYPES = {
+            "list": list, "tuple": tuple, "set": set, "frozenset": frozenset, 
+            "dict": dict, "str": str, "int": int, "float": float, "bool": bool,
+            "bytes": bytes, "bytearray": bytearray
+        }
+
+        # 3. Validación y Reconstrucción del Root
+        # Recuperamos el tipo de dato principal
+        raw_type = data.get("DATA_TYPE")
+        data_type = SAFE_TYPES.get(raw_type)
+        if not data_type:
+            raise TypeError(f"Invalid root data type: {raw_type}")
+
+        # Procesamos los possible_values con el motor recursivo
+        raw_possible = data.get("POSSIBLE_VALUES")
+        possible_values = cls._deserialize_recursive(raw_possible) if raw_possible is not None else None
+        
+        # Corrección de tipo para tuplas (JSON no tiene tuplas, devuelve listas)
+        # Si su __init__ es estricto y requiere tupla para possible_values, convertimos aquí:
+        if isinstance(possible_values, list) and data_type != dict:
+             possible_values = tuple(possible_values)
+        
+        # Para dicts, mantenemos la lista de listas o convertimos según su preferencia estricta
+        if isinstance(possible_values, list) and data_type == dict:
+             # Opcional: convertir sub-listas a tuplas si su validador lo prefiere, 
+             # aunque su validación actual acepta listas.
+             pass
+
+        return cls(
+            data_type=data_type,
+            value=data.get("VALUE"), # Asumimos valor literal o serializable simple
+            maximum_length=data.get("MAXIMUM_LENGTH"),
+            minimum_length=data.get("MINIMUM_LENGTH"),
+            possible_values=possible_values,
+            data_class=data.get("DATA_CLASS", False)
+        )
+
+    
+    @classmethod
+    def from_json(cls, text_content: str) -> 'ComplexData':
+        try:
+            data = json.loads(text_content)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON: {e}")
+        return cls.from_dict(data)
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), indent=4)
+    
     def validate(self, data: Any = None) -> bool:
         # Determine objective data
         if data is None:

datavalue/classes/primitive_data.py

@@ -53,21 +53,66 @@ class PrimitiveData:
             "MINIMUM_SIZE":self.minimum_size,
             "POSSIBLE_VALUES":self.possible_values if self.possible_values is not None else None,
             "REGULAR_EXPRESSION":self.regular_expression,
-            "DATA_CLASS":self.data_class
+            "DATA_CLASS":self.data_class,
+            "__type__":"PrimitiveData"
         }
     
     def to_json(self) -> str:
         return json.dumps(self.to_dict(), indent=4)
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> 'PrimitiveData':
+        # Expected keys definition
+        expected_keys = {
+            "DATA_TYPE", "VALUE", "MAXIMUM_LENGTH", "MINIMUM_LENGTH",
+            "MAXIMUM_SIZE", "MINIMUM_SIZE", "POSSIBLE_VALUES",
+            "REGULAR_EXPRESSION", "DATA_CLASS", "__type__"
+        }
+        
+        # Verify unknown keys on the table
+        unknown_keys = set(data.keys()) - expected_keys
+        if unknown_keys:
+            raise ValueError(f"Unknown keys in data structure: {unknown_keys}")
 
-    def from_json(self, text_content: str) -> dict:
-        data_table = json.loads(text_content)
-        local_table = self.to_dict()
+        # Secure type mapping
+        type_mapping = {
+            "str": str,
+            "int": int,
+            "float": float,
+            "bool": bool,
+            "bytes": bytes,
+            "bytearray": bytearray,
+            "NoneType": type(None)
+        }
 
-        for element in data_table:
-            if element not in local_table: raise ValueError(f"The loaded table has a unknown value: {element}")
+        type_str = data.get("DATA_TYPE")
+        real_type = type_mapping.get(type_str)
 
-        return data_table
+        if real_type is None and type_str != "None":
+             raise TypeError(f"Unsupported or unsafe data type for deserialization: {type_str}")
+
+        # return instance result
+        return cls(
+            data_type=real_type,
+            value=data.get("VALUE"),
+            maximum_length=data.get("MAXIMUM_LENGTH"),
+            minimum_length=data.get("MINIMUM_LENGTH"),
+            maximum_size=data.get("MAXIMUM_SIZE"),
+            minimum_size=data.get("MINIMUM_SIZE"),
+            possible_values=data.get("POSSIBLE_VALUES"),
+            regular_expression=data.get("REGULAR_EXPRESSION"),
+            data_class=data.get("DATA_CLASS", False)
+        )
         
+    @classmethod
+    def from_json(cls, text_content: str) -> 'PrimitiveData':
+        try:
+            data_table = json.loads(text_content)
+        except json.JSONDecodeError as Error:
+            raise ValueError(f"Invalid JSON format: {Error}")
+            
+        return cls.from_dict(data_table)
+
     def validate(self, data: Optional[Any] = None) -> bool:
         # Define the data to validate
         if data is None:

{datavalue-0.1.6.dist-info → datavalue-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datavalue
-Version: 0.1.6
+Version: 0.1.8
 Summary: Librería de tipos de datos primitivos y complejos
 Author: Specter
 Requires-Python: >=3.10

datavalue-0.1.8.dist-info/RECORD

@@ -0,0 +1,9 @@
+datavalue/__init__.py,sha256=-JBKpLEehjnezX3sTbpnB2px3izjHxZ_IEL_40iRHMM,112
+datavalue/classes/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+datavalue/classes/complex_data.py,sha256=fYBl-whK1MUivzoDI0aCXD1yfRPIMK-Pu9jlxQTtxiQ,10951
+datavalue/classes/primitive_data.py,sha256=YBr0i2FRonCwK4XQsNmoWtcIjd4VxQErTmzXVIIq_qg,7304
+datavalue/exceptions/__init__.py,sha256=T9X1N0kAv6RNTuTNQR7aTAxxvF25ihMsrtZGD-QZrBI,361
+datavalue-0.1.8.dist-info/METADATA,sha256=tcjBvTwfFA0Y-3wNGLqDoIo9ja82Qbgg8ecLoAb_-ro,1597
+datavalue-0.1.8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+datavalue-0.1.8.dist-info/top_level.txt,sha256=tVZ_--yYzvlZ2XTCkdORn4KKL7BwXPZUOVpL6PBJaRY,10
+datavalue-0.1.8.dist-info/RECORD,,

datavalue-0.1.6.dist-info/RECORD

@@ -1,9 +0,0 @@
-datavalue/__init__.py,sha256=-JBKpLEehjnezX3sTbpnB2px3izjHxZ_IEL_40iRHMM,112
-datavalue/classes/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-datavalue/classes/complex_data.py,sha256=Z6LjGqjXyGLjzrAVs09M4NfQz9P7H-ZIrijR1s-Mg_0,5581
-datavalue/classes/primitive_data.py,sha256=2IPScXGKuam32jdx1hbk0VxKS3mowwSBdM45Iigir3k,5691
-datavalue/exceptions/__init__.py,sha256=T9X1N0kAv6RNTuTNQR7aTAxxvF25ihMsrtZGD-QZrBI,361
-datavalue-0.1.6.dist-info/METADATA,sha256=rSve4eGV5Wh8RpQRvp5Ig-wWH2RZjHkYMj93C-qNSrY,1597
-datavalue-0.1.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-datavalue-0.1.6.dist-info/top_level.txt,sha256=tVZ_--yYzvlZ2XTCkdORn4KKL7BwXPZUOVpL6PBJaRY,10
-datavalue-0.1.6.dist-info/RECORD,,