datavalue 0.1.6__tar.gz → 0.1.8__tar.gz

{datavalue-0.1.6 → datavalue-0.1.8}/PKG-INFO

@@ -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.6 → datavalue-0.1.8}/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-0.1.6 → datavalue-0.1.8}/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 → datavalue-0.1.8}/datavalue.egg-info/PKG-INFO

@@ -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.6 → datavalue-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "datavalue"
-version = "0.1.6" 
+version = "0.1.8" 
 description = "Librería de tipos de datos primitivos y complejos"
 readme = "README.md"
 authors = [{ name="Specter" }]