datavalue 0.1.5__tar.gz → 0.1.7__tar.gz

{datavalue-0.1.5 → datavalue-0.1.7}/PKG-INFO

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

datavalue-0.1.7/datavalue/__init__.py

@@ -0,0 +1,3 @@
+# Library import
+from .classes.primitive_data import PrimitiveData
+from .classes.complex_data import ComplexData

datavalue-0.1.7/datavalue/classes/complex_data.py

@@ -0,0 +1,253 @@
+# Library import
+from typing import Type, Optional, Any, Iterable
+from .. import exceptions
+from .primitive_data import PrimitiveData
+import json
+
+# Classes definition
+class ComplexData:
+    def __init__(self,
+        data_type: Type[list] | Type[tuple] | Type[set] | Type[frozenset] | Type[dict],
+        value: Any,
+        maximum_length: Optional[int] = None, minimum_length: Optional[int] = None,
+        possible_values: Optional[Iterable] = None,
+        
+        data_class: Optional[bool] = False
+    ) -> None:
+        # Instance properties assignment
+        self.data_type = data_type
+        self.value = value
+        self.maximum_length = maximum_length; self.minimum_length = minimum_length
+        self.possible_values = possible_values
+        self.data_class = data_class
+
+        # Validate constructor parameters
+        if self.possible_values:
+            # Base validation: it has to be a collection
+            if not isinstance(self.possible_values, (list, tuple)):
+                raise ValueError(f"The possible values has to be a list/tuple. Received: {type(self.possible_values).__name__}")
+            
+            # Validation to collections (list, tuple, set, frozenset)
+            if self.data_type != dict:
+                if not isinstance(self.possible_values, (list, tuple)):
+                    raise ValueError(f"Possible values for {self.data_type.__name__} must be exactly one list/tuple containing the options.")
+            
+            # Specific validation for dicts
+            else: # self.data_type == dict
+                if len(self.possible_values) not in (1, 2):
+                    raise ValueError("Possible values for dict must be 1 (keys) or 2 (keys, values) list/tuples.")
+                
+                # Validate the first element
+                if not isinstance(self.possible_values[0], (list, tuple)):
+                    raise ValueError("The first element of possible_values for dict must be a list/tuple of keys.")
+                
+                # Validate the second element
+                if len(self.possible_values) == 2 and not isinstance(self.possible_values[1], (list, tuple)):
+                    raise ValueError("The second element of possible_values for dict must be a list/tuple of value validators.")
+        
+        # Execute instance data validation
+        if not self.data_class:
+            self.validate()
+    
+    # Private methods
+    def _is_match(self, element: Any, schema: Any) -> bool:
+        # Validate data types
+        if isinstance(schema, (PrimitiveData, ComplexData)):
+            try:
+                return schema.validate(element)
+            except:
+                return False
+        
+        # Validate class data types
+        if isinstance(schema, type):
+            return isinstance(element, schema)
+    
+        # Validate literal values
+        return element == schema
+            
+    def _validate_collection(self, data: Any) -> bool:
+        element_index: int = 0
+        for element in data:
+            if not any(self._is_match(element, validator) for validator in self.possible_values):
+                raise ValueError(f"[ComplexData] Element: {element}, on index: {element_index} is not allowed.")
+            element_index += 1
+        
+        # Return results
+        return True
+    
+    def _validate_dictionary(self, data: Any) -> bool:
+        # Validate keys and (if applies) values
+        if not isinstance(self.possible_values, (list, tuple)) or len(self.possible_values) != 2:
+            keys_schema = self.possible_values
+            values_schema = None
+        else:
+            keys_schema, values_schema = self.possible_values
+        
+        for key, value in data.items():
+            # Validación de Claves (Debe ser un iterable de opciones)
+            if keys_schema:
+                if not any(self._is_match(key, validator) for validator in keys_schema):
+                    raise ValueError(f"[ComplexData] Invalid key: {key}")
+            
+            # Validación de Valores
+            if values_schema:
+                if not any(self._is_match(value, validator) for validator in values_schema):
+                    raise ValueError(f"[ComplexData] Invalid value '{value}' for key '{key}'")
+
+        return True
+        
+    def _serialize_recursive(self, 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 [self._serialize_recursive(i) for i in element]
+        
+        if isinstance(element, dict):
+            return {str(k): self._serialize_recursive(v) for k, v in element.items()}
+        
+        # 4. Caso: Literales serializables (int, str, float, bool, None)
+        return element
+
+    def _deserialize_recursive(self, 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(value=None, data_type=None, data_class=True).from_dict(content)
+                elif obj_type == "ComplexData":
+                    return self.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: self._deserialize_recursive(v) for k, v in element.items()}
+
+        # B. Manejo de Listas (recurse items)
+        if isinstance(element, list):
+            return [self._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
+        }
+
+    
+    def from_dict(self, 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 = self._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 ComplexData(
+            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)
+        )
+
+    
+    def from_json(self, text_content: str) -> 'ComplexData':
+        try:
+            data = json.loads(text_content)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON: {e}")
+        return self.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:
+            objective_data = self.value
+        else:
+            objective_data = data
+
+        # Data type validation
+        if not isinstance(objective_data, self.data_type):
+            raise exceptions.DataTypeException(
+                f"Incorrect data type.\nExpected: {self.data_type.__name__} - Received: {type(objective_data).__name__}"
+            )
+    
+        # Length validation
+        current_length = len(objective_data)
+        
+        if self.minimum_length is not None and current_length < self.minimum_length:
+            raise ValueError(f"Minimum length not reached: {current_length} < {self.minimum_length}")
+    
+        if self.maximum_length is not None and current_length > self.maximum_length:
+            raise ValueError(f"Maximum length reached: {current_length} > {self.maximum_length}")
+    
+        # Content validation and recurse
+        if self.possible_values:
+            # Validate dictionaries
+            if isinstance(objective_data, dict):
+                self._validate_dictionary(objective_data)
+            else:
+                self._validate_collection(objective_data)
+        
+        # Return results
+        return True

{datavalue-0.1.5 → datavalue-0.1.7}/datavalue/classes/primitive_data.py

@@ -2,6 +2,7 @@
 import re
 from typing import Type, Optional, Any, Iterable, Union
 from .. import exceptions
+import json
 
 # Classes definition
 class PrimitiveData:
@@ -54,7 +55,62 @@ class PrimitiveData:
             "REGULAR_EXPRESSION":self.regular_expression,
             "DATA_CLASS":self.data_class
         }
+    
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), indent=4)
+
+    
+    def from_dict(self, 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"
+        }
+        
+        # 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)
+        }
+
+        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}")
+
+        # return instance result
+        return PrimitiveData(
+            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)
+        )
         
+    def from_json(self, text_content: str) -> 'PrimitiveData':
+        try:
+            data_table = json.loads(text_content)
+        except json.JSONDecodeError as Error:
+            raise ValueError(f"Invalid JSON format: {Error}")
+            
+        return self.from_dict(data_table)
+
     def validate(self, data: Optional[Any] = None) -> bool:
         # Define the data to validate
         if data is None:

{datavalue-0.1.5 → datavalue-0.1.7}/datavalue.egg-info/PKG-INFO

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

{datavalue-0.1.5 → datavalue-0.1.7}/datavalue.egg-info/SOURCES.txt

@@ -6,6 +6,6 @@ datavalue.egg-info/SOURCES.txt
 datavalue.egg-info/dependency_links.txt
 datavalue.egg-info/top_level.txt
 datavalue/classes/__init__.py
+datavalue/classes/complex_data.py
 datavalue/classes/primitive_data.py
-datavalue/exceptions/__init__.py
-tests/test.py
+datavalue/exceptions/__init__.py

datavalue-0.1.7/datavalue.egg-info/top_level.txt

@@ -0,0 +1 @@
+datavalue

{datavalue-0.1.5 → datavalue-0.1.7}/pyproject.toml

@@ -4,11 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "datavalue"
-version = "0.1.5" 
+version = "0.1.7" 
 description = "Librería de tipos de datos primitivos y complejos"
 readme = "README.md"
 authors = [{ name="Specter" }]
 requires-python = ">=3.10"
 
-[tool.setuptools]
-packages = { find = {} }
+[tool.setuptools.packages.find]
+include = ["datavalue*"]
+exclude = ["docs*"]

datavalue-0.1.5/datavalue/__init__.py

@@ -1,2 +0,0 @@
-# Library import
-from .classes.primitive_data import PrimitiveData

datavalue-0.1.5/datavalue.egg-info/top_level.txt

@@ -1,4 +0,0 @@
-datavalue
-dist
-docs
-tests

datavalue-0.1.5/tests/test.py

@@ -1,62 +0,0 @@
-# Library import
-from datavalue import PrimitiveData
-
-# Phone number validation
-print("="*10)
-print("Validating phone number...")
-phone_number = PrimitiveData(
-  data_type=str,
-  value="+34600111222",
-  minimum_length=7, # Minimum character length
-  maximum_length=15, # Maximum character length
-  minimum_size=None, # Not validate the minimum number
-  maximum_size=None, # Not validate the maximum number,
-  possible_values=None, # Not specify obligatory possible values
-  regular_expression=r"^\+[1-9]\d{6,14}$"
-)
-
-print("Phone number validated sucessfully:", phone_number.value)
-
-# Connection port validation
-print("="*10)
-print("Validating connection port...")
-connection_port = PrimitiveData(
-  data_type=int,
-  value=45321,
-  minimum_length=1, # Maximum digits
-  maximum_length=5, # Minimum digits
-  minimum_size=1, # Minimum numerical value
-  maximum_size=65535, # Maximum numerical value
-  possible_values=None, # Possible options
-  regular_expression=None # Regular expression applied
-)
-print("Connection port validated:", connection_port.value)
-
-# Transport protocol validation
-print("="*10)
-print("Validating transport protocol...")
-transport_protocol = PrimitiveData(
-  data_type=str,
-  value="TCP",
-  maximum_length=None,
-  minimum_length=None,
-  minimum_size=None,
-  maximum_size=None,
-  possible_values=("TCP", "UDP"),
-  regular_expression=None
-)
-print("Transport protocol validated:", transport_protocol.value)
-
-# Validating IPv4 address
-print("="*10)
-print("Validating IPv4 address...")
-ip_address = PrimitiveData(
-  data_type=str,
-  value="192.168.0.1",
-  maximum_length=15,
-  minimum_length=7,
-  maximum_size=None, minimum_size=None,
-  possible_values=None,
-  regular_expression=r"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
-)
-print("IPv4 address validated:", ip_address.value)