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

datavalue/__init__.py

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

datavalue/classes/complex_data.py

@@ -0,0 +1,130 @@
+# Library import
+from typing import Type, Optional, Any, Iterable
+from .. import exceptions
+from .primitive_data import PrimitiveData
+
+# 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
+        
+    # Public methods
+    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/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,6 +55,18 @@ 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_json(self, text_content: str) -> dict:
+        data_table = json.loads(text_content)
+        local_table = self.to_dict()
+
+        for element in data_table:
+            if element not in local_table: raise ValueError(f"The loaded table has a unknown value: {element}")
+
+        return data_table
         
     def validate(self, data: Optional[Any] = None) -> bool:
         # Define the data to validate

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

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

datavalue-0.1.6.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=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,,

{datavalue-0.1.5.dist-info → datavalue-0.1.6.dist-info}/top_level.txt

@@ -1,2 +1 @@
 datavalue
-tests

datavalue-0.1.5.dist-info/RECORD

@@ -1,9 +0,0 @@
-datavalue/__init__.py,sha256=QHthd6CQaDPqpvS3ay1r_Z7WvIleUXbTAottuML8nPA,66
-datavalue/classes/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-datavalue/classes/primitive_data.py,sha256=qsKlds33RqR0bIGjy-5kgZdNBcrBMITbrvVx4HqeO-M,5281
-datavalue/exceptions/__init__.py,sha256=T9X1N0kAv6RNTuTNQR7aTAxxvF25ihMsrtZGD-QZrBI,361
-tests/test.py,sha256=8-AhuPJk0Yxt49MmbbdqGamhWM87T9mkbfmIU3BZZJk,1845
-datavalue-0.1.5.dist-info/METADATA,sha256=71CLQrhr8mhSMINt4ha0p1PxHdOtOcPRIKGWss2LvD0,1597
-datavalue-0.1.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-datavalue-0.1.5.dist-info/top_level.txt,sha256=zlD2cuGB4gcH2hf8HIBij-0hqp_7e-c2e5nn6-A9j1Y,16
-datavalue-0.1.5.dist-info/RECORD,,

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)