datavalue 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

datavalue/classes/primitive_data.py

@@ -59,17 +59,28 @@ class PrimitiveData:
     
     # Public methods
     def to_dict(self) -> dict:
+        normalized_possible = None
+        if self.possible_values is not None:
+            normalized_possible = []
+            for item in self.possible_values:
+                if isinstance(item, PrimitiveData):
+                    normalized_possible.append(item.to_dict())
+                elif isinstance(item, type):
+                    normalized_possible.append({"__class__": item.__name__})
+                else:
+                    normalized_possible.append(item)
+
         return {
-            "DATA_TYPE":self.data_type.__name__ if hasattr(self.data_type, '__name__') else str(self.data_type),
-            "VALUE":self.value,
-            "MAXIMUM_LENGTH":self.maximum_length,
-            "MINIMUM_LENGTH":self.minimum_length,
-            "MAXIMUM_SIZE":self.maximum_size,
-            "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,
-            "__type__":"PrimitiveData"
+            "DATA_TYPE": self.data_type.__name__ if hasattr(self.data_type, '__name__') else str(self.data_type),
+            "VALUE": self.value,
+            "MAXIMUM_LENGTH": self.maximum_length,
+            "MINIMUM_LENGTH": self.minimum_length,
+            "MAXIMUM_SIZE": self.maximum_size,
+            "MINIMUM_SIZE": self.minimum_size,
+            "POSSIBLE_VALUES": normalized_possible,
+            "REGULAR_EXPRESSION": self.regular_expression,
+            "DATA_CLASS": self.data_class,
+            "__type__": "PrimitiveData"
         }
     
     def to_json(self) -> str:
@@ -77,36 +88,45 @@ class PrimitiveData:
     
     @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}")
 
         # Secure type mapping
         type_mapping = {
-            "str": str,
-            "int": int,
-            "float": float,
-            "bool": bool,
-            "bytes": bytes,
-            "bytearray": bytearray,
-            "NoneType": type(None)
+            "str": str, "int": int, "float": float, "bool": bool,
+            "bytes": bytes, "bytearray": bytearray, "NoneType": type(None)
         }
 
         type_str = data.get("DATA_TYPE")
         real_type = type_mapping.get(type_str)
 
         if real_type is None and type_str != "None":
-             raise TypeError(f"Unsupported or unsafe data type for deserialization: {type_str}")
+             raise TypeError(f"Unsupported or unsafe data type: {type_str}")
+
+        # --- NORMALIZACIÓN DE POSSIBLE_VALUES (DESERIALIZACIÓN) ---
+        raw_possible = data.get("POSSIBLE_VALUES")
+        possible_values = None
+        if raw_possible is not None:
+            possible_values = []
+            for item in raw_possible:
+                if isinstance(item, dict):
+                    if item.get("__type__") == "PrimitiveData":
+                        possible_values.append(cls.from_dict(item))
+                    elif "__class__" in item:
+                        possible_values.append(type_mapping.get(item["__class__"]))
+                    else:
+                        possible_values.append(item)
+                else:
+                    possible_values.append(item)
+        # ----------------------------------------------------------
 
-        # return instance result
         return cls(
             data_type=real_type,
             value=data.get("VALUE"),
@@ -114,7 +134,7 @@ class PrimitiveData:
             minimum_length=data.get("MINIMUM_LENGTH"),
             maximum_size=data.get("MAXIMUM_SIZE"),
             minimum_size=data.get("MINIMUM_SIZE"),
-            possible_values=data.get("POSSIBLE_VALUES"),
+            possible_values=possible_values,
             regular_expression=data.get("REGULAR_EXPRESSION"),
             data_class=data.get("DATA_CLASS", False)
         )

{datavalue-0.1.12.dist-info → datavalue-0.1.13.dist-info}/METADATA

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

{datavalue-0.1.12.dist-info → datavalue-0.1.13.dist-info}/RECORD

@@ -1,9 +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=Tb0S76ot5x66XLeqR-4f6ynqt60LcCHN_ydFsmn6co0,8050
+datavalue/classes/primitive_data.py,sha256=Cm5DvIrKWM6LWETl06zK1v4JZWkw5DaXPMow9VTHeZU,9072
 datavalue/exceptions/__init__.py,sha256=T9X1N0kAv6RNTuTNQR7aTAxxvF25ihMsrtZGD-QZrBI,361
-datavalue-0.1.12.dist-info/METADATA,sha256=rsEauafgjSgy5ktB-N1PpYxTRwmVSbusjfE_Yhr6oec,1598
-datavalue-0.1.12.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-datavalue-0.1.12.dist-info/top_level.txt,sha256=tVZ_--yYzvlZ2XTCkdORn4KKL7BwXPZUOVpL6PBJaRY,10
-datavalue-0.1.12.dist-info/RECORD,,
+datavalue-0.1.13.dist-info/METADATA,sha256=gD38QSnBU94KbSBEFN1QgIEEdrzG6nJzQugy3nSKZEY,1598
+datavalue-0.1.13.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+datavalue-0.1.13.dist-info/top_level.txt,sha256=tVZ_--yYzvlZ2XTCkdORn4KKL7BwXPZUOVpL6PBJaRY,10
+datavalue-0.1.13.dist-info/RECORD,,