datavalue 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

datavalue/classes/__init__.py

@@ -0,0 +1 @@
+

datavalue/classes/primitive_data.py

@@ -0,0 +1,112 @@
+# Library import
+import re
+from typing import Type, Optional, Any, Iterable, Union
+from .. import exceptions
+
+# Classes definition
+class PrimitiveData:
+    def __init__(self,
+        data_type: Type,
+        value: Any,
+        maximum_length: Optional[int] = None, minimum_length: Optional[int] = None,
+        maximum_size: Optional[Union[int, float]] = None, minimum_size: Optional[Union[int, float]] = None,
+        possible_values: Optional[Iterable] = None,
+        regular_expression: Optional[str] = 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.maximum_size = maximum_size; self.minimum_size = minimum_size
+        self.possible_values = possible_values
+        self.regular_expression = regular_expression
+        self.data_class = data_class
+        
+        if not self.data_class:
+            self.validate()
+    
+    # Private methods
+    def __get_length(self, data: Optional[Any] = None) -> Optional[int]:
+        if data is None:
+            data_objective = self.value
+        else:
+            data_objective = data
+
+        if isinstance(data_objective, (str, bytes, bytearray)):
+            return len(data_objective)
+        elif isinstance(data_objective, (int, float)):
+            return len([digit for digit in str(data_objective) if digit.isdigit()])
+        else:
+            return None
+    
+    # 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.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
+        }
+        
+    def validate(self, data: Optional[Any] = None) -> bool:
+        # Define the data to validate
+        if data is None:
+            data_objective = self.value
+        else:
+            data_objective = data
+
+        # Validacion de tipo de dato
+        if not isinstance(data_objective, self.data_type):
+            raise exceptions.DataTypeException(
+                f"Incorrect data type.\nExpected: {self.data_type.__name__} - Received: {type(data_objective).__name__}"
+            )
+        
+        # Validacion de longitud de caracteres (minimo, y maximo)
+        if self.minimum_length is not None or self.maximum_length is not None:
+            length = self.__get_length(data_objective)
+            
+            if length is not None:
+                if self.minimum_length is not None and length < self.minimum_length:
+                    raise exceptions.LengthException(f"Character/digit length below the minimum: {length} < {self.minimum_length}")
+                elif self.maximum_length is not None and length > self.maximum_length:
+                    raise exceptions.LengthException(f"Character/digit length above the maximum: {length} > {self.maximum_length}")
+        
+        # Validacion de tamaño (magnitud)
+        if self.minimum_size is not None or self.maximum_size is not None:
+            if isinstance(data_objective, (int, float)):
+                if self.minimum_size is not None and data_objective < self.minimum_size:
+                    raise exceptions.SizeException(f"Numerical value below the minimum: {data_objective} < {self.minimum_size}")
+                if self.maximum_size is not None and data_objective > self.maximum_size:
+                    raise exceptions.SizeException(f"Numerical value above the maximum: {data_objective} > {self.maximum_size}")
+        
+        # Validacion de posibles valores (conjunto)
+        if self.data_type is bool:
+            if data_objective not in (True, False):
+                raise exceptions.PossibleValueException(
+                    f"The boolean value has to be True or False: {data_objective} != True/False"
+                )
+        if self.possible_values is not None:
+            if data_objective not in self.possible_values:
+                raise exceptions.PossibleValueException(
+                    f"The value is not in the possible values set: {data_objective} not in {self.possible_values}"
+                )
+        
+        # Validacion de expresion regular
+        if self.regular_expression is not None:
+            if isinstance(data_objective, (str, bytes, bytearray)):
+                # Soporte para bytes/bytearray convirtiendo el patrón si es necesario
+                pattern = self.regular_expression
+                if isinstance(data_objective, (bytes, bytearray)) and isinstance(pattern, str):
+                    pattern = pattern.encode()
+                
+                if not re.fullmatch(pattern, data_objective):
+                    raise exceptions.RegularExpressionException(f"The value does not meet the required pattern: {self.regular_expression}")
+        
+        return True

datavalue/exceptions/__init__.py

@@ -0,0 +1,10 @@
+# Classes definition
+# Base exception
+class DataValueException(Exception): pass
+
+# Specific exceptions
+class DataTypeException(DataValueException): pass
+class LengthException(DataValueException): pass
+class SizeException(DataValueException): pass
+class PossibleValueException(DataValueException): pass
+class RegularExpressionException(DataValueException): pass

{datavalue-0.1.2.dist-info → datavalue-0.1.4.dist-info}/METADATA

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

datavalue-0.1.4.dist-info/RECORD

@@ -0,0 +1,9 @@
+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.4.dist-info/METADATA,sha256=85qTmyY5lcP96JpIi000IqYtvd-O23ZSTiL03SZymHc,1597
+datavalue-0.1.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+datavalue-0.1.4.dist-info/top_level.txt,sha256=zlD2cuGB4gcH2hf8HIBij-0hqp_7e-c2e5nn6-A9j1Y,16
+datavalue-0.1.4.dist-info/RECORD,,

{datavalue-0.1.2.dist-info → datavalue-0.1.4.dist-info}/top_level.txt

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

tests/test.py

@@ -0,0 +1,62 @@
+# 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)

datavalue-0.1.2.dist-info/RECORD

@@ -1,5 +0,0 @@
-datavalue/__init__.py,sha256=QHthd6CQaDPqpvS3ay1r_Z7WvIleUXbTAottuML8nPA,66
-datavalue-0.1.2.dist-info/METADATA,sha256=eFUJRXdcLKGBfgfGqFq16SgN8uECGtYKzoIP7ssCisE,1597
-datavalue-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-datavalue-0.1.2.dist-info/top_level.txt,sha256=tVZ_--yYzvlZ2XTCkdORn4KKL7BwXPZUOVpL6PBJaRY,10
-datavalue-0.1.2.dist-info/RECORD,,