data-sitter 0.1.3__tar.gz → 0.1.4__tar.gz

{data_sitter-0.1.3 → data_sitter-0.1.4}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.2
 Name: data-sitter
-Version: 0.1.3
+Version: 0.1.4
 Summary: A Python library that reads data contracts and generates Pydantic models for seamless data validation.
 Author-email: Lázaro Pereira Candea <lazaro@candea.es>
 Requires-Dist: python-dotenv==1.0.1
+Requires-Dist: PyYAML==6.0.2
 Requires-Dist: parse_type==0.6.4
 Requires-Dist: pydantic==2.10.5

{data_sitter-0.1.3 → data_sitter-0.1.4}/README.md

@@ -13,10 +13,8 @@ Data-Sitter is a Python library designed to simplify data validation by converti
 
 ## Installation
 
-You can install Data-Sitter directly from GitHub:
-
 ```sh
-pip install git+https://github.com/Kenr0t/data-sitter.git@main
+pip install data-sitter
 ```
 
 ## Usage
@@ -94,39 +92,46 @@ Below are the available rules grouped by field type:
 
 #### BaseField
 
-- Validate Not Null
+- Is not null
 
 #### StringField - (Inherits from `BaseField`)
 
 - Is not empty
-- Starts with `{prefix:String}`
-- Ends with `{sufix:String}`
-- Value in `{possible_values:Strings}`
-- Length between `{min_val:Integer}` and `{max_val:Integer}`
-- Maximum length of `{max_len:Integer}`
-- Length shorter than `{max_len:Integer}`
-- Minimum length of `{min_len:Integer}`
-- Length longer than `{min_len:Integer}`
+- Starts with {prefix:String}
+- Ends with {suffix:String}
+- Is not one of {possible_values:Strings}
+- Is one of {possible_values:Strings}
+- Has length between {min_val:Integer} and {max_val:Integer}
+- Has maximum length {max_len:Integer}
+- Has minimum length {min_len:Integer}
 - Is uppercase
+- Is lowercase
+- Matches regex {pattern:String}
+- Is valid email
+- Is valid URL
+- Has no digits
 
 #### NumericField - (Inherits from `BaseField`)
 
-- Not Zero
-- Positive
-- Negative
-- Minimum `{min_val:Number}`
-- Maximum `{max_val:Number}`
-- Greater than `{threshold:Number}`
-- Less than `{threshold:Number}`
-- Between `{min_val:Number}` and `{max_val:Number}`
+- Is not zero
+- Is positive
+- Is negative
+- Is at least {min_val:Number}
+- Is at most {max_val:Number}
+- Is greater than {threshold:Number}
+- Is less than {threshold:Number}
+- Is not between {min_val:Number} and {max_val:Number}
+- Is between {min_val:Number} and {max_val:Number}
 
 #### IntegerField  - (Inherits from `NumericField`)
 
 #### FloatField  - (Inherits from `NumericField`)
 
+- Has at most {decimal_places:Integer} decimal places
+
 ## Contributing
 
-Contributions are welcome! Feel free to submit issues or pull requests in the [GitHub repository](https://github.com/Kenr0t/data-sitter).
+Contributions are welcome! Feel free to submit issues or pull requests in the [GitHub repository](https://github.com/lcandea/data-sitter).
 
 ## License
 

{data_sitter-0.1.3 → data_sitter-0.1.4}/data_sitter/Contract.py

@@ -1,3 +1,5 @@
+import json
+import yaml
 from typing import Any, Dict, List, NamedTuple
 from functools import cached_property
 
@@ -52,6 +54,14 @@ class Contract:
             values=contract_dict.get("values", {}),
         )
 
+    @classmethod
+    def from_json(cls, contract_json: str):
+        return cls.from_dict(json.loads(contract_json))
+
+    @classmethod
+    def from_yaml(cls, contract_yaml: str):
+        return cls.from_dict(yaml.load(contract_yaml, yaml.Loader))
+
     @cached_property
     def field_validators(self) -> Dict[str, BaseField]:
         field_validators = {}
@@ -83,7 +93,28 @@ class Contract:
             }
         })
 
-    def get_front_end_contract(self):
+    @cached_property
+    def contract(self) -> dict:
+        return {
+            "name": self.name,
+            "fields": [
+                {
+                    "field_name": field_name,
+                    "field_type": field_validator.__class__.__name__,
+                    "field_rules": [rule.parsed_rule for rule in self.rules.get(field_name, [])]
+                }
+                for field_name, field_validator in self.field_validators.items()
+            ],
+            "values": self.rule_parser.values
+        }
+
+    def get_json_contract(self, indent: int=2) -> str:
+        return json.dumps(self.contract, indent=indent)
+
+    def get_yaml_contract(self, indent: int=2) -> str:
+        return yaml.dump(self.contract, Dumper=yaml.Dumper, indent=indent, sort_keys=False)
+
+    def get_front_end_contract(self) -> dict:
         return {
             "name": self.name,
             "fields": [

{data_sitter-0.1.3 → data_sitter-0.1.4}/data_sitter/FieldResolver.py

@@ -1,4 +1,3 @@
-
 from typing import  Dict, List, Type
 
 from .field_types import BaseField
@@ -32,8 +31,7 @@ class FieldResolver:
         return matched_rules
 
     def get_field_validator(self, field_name: str, parsed_rules: List[str]) -> BaseField:
-        is_optional = "Validate Not Null" not in parsed_rules
-        validator = self.field_class(field_name, is_optional)
+        validator = self.field_class(field_name)
         matched_rules = self.get_matched_rules(parsed_rules)
         for matched_rule in matched_rules:
             matched_rule.add_to_instance(validator)

data_sitter-0.1.4/data_sitter/Validation.py

@@ -0,0 +1,39 @@
+from collections import defaultdict
+from typing import Any, Dict, List, Type
+
+from pydantic import BaseModel, ValidationError
+
+
+class Validation():
+    item: Dict[str, Any]
+    errors: Dict[str, List[str]]
+    unknowns: Dict[str, Any]
+
+    def __init__(self, item: dict, errors: dict = None, unknowns: dict = None):
+        self.item = item
+        self.errors = errors if errors else None
+        self.unknowns = unknowns if unknowns else None
+
+    def to_dict(self) -> dict:
+        return {key: value for key in ["item", "errors", "unknowns"] if (value := getattr(self, key))}
+
+    @classmethod
+    def validate(cls, PydanticModel: Type[BaseModel], input_item: dict) -> "Validation":
+        model_keys = PydanticModel.model_json_schema()['properties'].keys()
+        item = {key: None for key in model_keys}  # Filling not present values with Nones
+        errors = defaultdict(list)
+        unknowns = {}
+        for key, value in input_item.items():
+            if key in item:
+                item[key] = value
+            else:
+                unknowns[key] = value
+        try:
+            validated = PydanticModel(**item).model_dump()
+        except ValidationError as e:
+            validated = item
+            for error in e.errors():
+                field = error['loc'][0]  # Extract the field name
+                msg = error['msg']
+                errors[field].append(msg)
+        return Validation(item=validated, errors=dict(errors), unknowns=unknowns)

{data_sitter-0.1.3 → data_sitter-0.1.4}/data_sitter/field_types/BaseField.py

@@ -21,20 +21,21 @@ class BaseField(ABC):
     validators = None
     field_type = None
 
-    def __init__(self, name: str, is_optional: bool) -> None:
+    def __init__(self, name: str) -> None:
         self.name = name
-        self.is_optional = is_optional
+        self.is_optional = True
         self.validators = []
 
-    @register_rule("Validate Not Null")
+    @register_rule("Is not null")
     def validator_not_null(self):
         def _validator(value):
             if self.is_optional:
                 return value
             if value is None:
-                raise ValueError("Value cannot be null")
+                raise ValueError("Value cannot be null.")
             return value
 
+        self.is_optional = False
         self.validators.append(_validator)
 
     def validate(self, value):

data_sitter-0.1.4/data_sitter/field_types/FloatField.py

@@ -0,0 +1,17 @@
+from .NumericField import NumericField
+from ..rules import register_field, register_rule
+
+
+@register_field
+class FloatField(NumericField):
+    field_type = float
+
+    @register_rule("Has at most {decimal_places:Integer} decimal places")
+    def validate_max_decimal_places(self, decimal_places: int):
+        def validator(value):
+            if not isinstance(value, float):
+                raise ValueError("Value must be a floating-point number.")
+            if len(str(value).split(".")[1]) > decimal_places:
+                raise ValueError(f"Value must have at most {decimal_places} decimal places.")
+            return value
+        self.validators.append(validator)

{data_sitter-0.1.3 → data_sitter-0.1.4}/data_sitter/field_types/NumericField.py

@@ -10,66 +10,70 @@ Numeric = Union[int, float]
 class NumericField(BaseField):
     field_type = Numeric
 
-    @register_rule("Not Zero")
+    @register_rule("Is not zero")
     def validate_non_zero(self):
         def validator(value: Numeric):
             if value == 0:
-                raise ValueError("Value must not be zero")
+                raise ValueError("Value cannot be zero.")
             return value
         self.validators.append(validator)
 
-    @register_rule("Positive")
+    @register_rule("Is positive")
     def validate_positive(self):
         def validator(value: Numeric):
             if value < 0:
-                raise ValueError(f"Value {value} is not positive")
+                raise ValueError("Value must be positive.")
             return value
         self.validators.append(validator)
 
-    @register_rule("Negative")
+    @register_rule("Is negative")
     def validate_negative(self):
         def validator(value: Numeric):
             if value >= 0:
-                raise ValueError(f"Value {value} is not negative")
+                raise ValueError("Value must be less than zero.")
             return value
         self.validators.append(validator)
 
-    @register_rule("Minimum {min_val:Number}")
+    @register_rule("Is at least {min_val:Number}")
     def validate_min(self, min_val: Numeric):
         def validator(value: Numeric):
             if value < min_val:
-                raise ValueError(f"Value {value} is less than minimum {min_val}")
+                raise ValueError(f"Value must be at least {min_val}.")
             return value
         self.validators.append(validator)
 
-    @register_rule("Maximum {max_val:Number}")
+    @register_rule("Is at most {max_val:Number}")
     def validate_max(self, max_val: Numeric):
         def validator(value: Numeric):
             if value > max_val:
-                raise ValueError(f"Value {value} exceeds maximum {max_val}")
+                raise ValueError(f"Value must not exceed {max_val}.")
             return value
         self.validators.append(validator)
 
-    @register_rule("Greate than {threshold:Number}")
+    @register_rule("Is greater than {threshold:Number}")
     def validate_greater_than(self, threshold: Numeric):
         def validator(value: Numeric):
             if value <= threshold:
-                raise ValueError(f"Value {value} is not greater than {threshold}")
+                raise ValueError(f"Value must be greater than {threshold}.")
             return value
         self.validators.append(validator)
 
-    @register_rule("Less than {threshold:Number}")
+    @register_rule("Is less than {threshold:Number}")
     def validate_less_than(self, threshold: Numeric):
         def validator(value: Numeric):
             if value >= threshold:
-                raise ValueError(f"Value {value} is not less than {threshold}")
+                raise ValueError(f"Value must be less than {threshold}.")
             return value
         self.validators.append(validator)
 
-    @register_rule("Between {min_val:Number} and {max_val:Number}")
-    def validate_between(self, min_val: Numeric, max_val: Numeric):
+    @register_rule("Is between {min_val:Number} and {max_val:Number}", fixed_params={"negative": False})
+    @register_rule("Is not between {min_val:Number} and {max_val:Number}", fixed_params={"negative": True})
+    def validate_between(self, min_val: Numeric, max_val: Numeric, negative: bool):
         def validator(value: Numeric):
-            if not (min_val < value < max_val):
-                raise ValueError(f"Value {value} not in Between {min_val} and {max_val}.")
+            condition = (min_val < value < max_val)
+            if condition and negative:
+                raise ValueError(f"Value must not be between {min_val} and {max_val}.")
+            if not condition and not negative:
+                raise ValueError(f"Value must be between {min_val} and {max_val}.")
             return value
         self.validators.append(validator)

data_sitter-0.1.4/data_sitter/field_types/StringField.py

@@ -0,0 +1,122 @@
+import re
+from typing import List
+
+from .BaseField import BaseField
+from ..rules import register_rule, register_field
+
+
+@register_field
+class StringField(BaseField):
+    field_type = str
+
+    @register_rule("Is not empty")
+    def validate_not_empty(self):
+        def validator(value: str):
+            if value == "":
+                raise ValueError("String cannot be empty.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Starts with {prefix:String}")
+    def validate_starts_with(self, prefix: List[str]):
+        def validator(value: str):
+            if not value.startswith(prefix):
+                raise ValueError(f"Value must start with '{prefix}'.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Ends with {suffix:String}")
+    def validate_ends_with(self, suffix: List[str]):
+        def validator(value: str):
+            if not value.endswith(suffix):
+                raise ValueError(f"Value must end with '{suffix}'.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Is one of {possible_values:Strings}", fixed_params={"negative": False})
+    @register_rule("Is not one of {possible_values:Strings}", fixed_params={"negative": True})
+    def validate_in(self, possible_values: List[str], negative: bool):
+        def validator(value: str):
+            condition = value in possible_values
+            if condition and negative:
+                raise ValueError(f"Value '{value}' is not allowed.")
+            if not condition and not negative:
+                raise ValueError(f"Value '{value}' must be one of the possible values.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Has length between {min_val:Integer} and {max_val:Integer}")
+    def validate_length_between(self, min_val: int, max_val: int):
+        def validator(value: str):
+            if not (min_val < len(value) < max_val):
+                raise ValueError(f"Length must be between {min_val} and {max_val} characters.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Has maximum length {max_len:Integer}")
+    def validate_max_length(self, max_len: int):
+        def validator(value: str):
+            if len(value) > max_len:
+                raise ValueError(f"Length must not exceed {max_len} characters.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Has minimum length {min_len:Integer}")
+    def validate_min_length(self, min_len: int):
+        def validator(value: str):
+            if len(value) < min_len:
+                raise ValueError(f"Length must be at least {min_len} characters.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Is uppercase")
+    def validate_uppercase(self):
+        def validator(value: str):
+            if not value.isupper():
+                raise ValueError("Value must be in uppercase.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Is lowercase")
+    def validate_lowercase(self):
+        def validator(value: str):
+            if not value.islower():
+                raise ValueError("Value must be in lowercase.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Matches regex {pattern:String}")
+    def validate_matches_regex(self, pattern: str):
+        def validator(value: str):
+            if not re.match(pattern, value):
+                raise ValueError(f"Value does not match the required pattern {pattern}.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Is valid email")
+    def validate_email(self):
+        EMAIL_REGEX = r"^[\w\.-]+@[\w\.-]+\.\w+$"
+
+        def validator(value: str):
+            if not re.match(EMAIL_REGEX, value):
+                raise ValueError("Invalid email format.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Is valid URL")
+    def validate_url(self):
+        URL_REGEX = r"^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$"
+
+        def validator(value: str):
+            if not re.match(URL_REGEX, value):
+                raise ValueError("Invalid URL format.")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Has no digits")
+    def validate_no_digits(self):
+        def validator(value: str):
+            if any(char.isdigit() for char in value):
+                raise ValueError("Value must not contain any digits.")
+            return value
+        self.validators.append(validator)

{data_sitter-0.1.3 → data_sitter-0.1.4}/data_sitter/rules/Rule.py

@@ -1,3 +1,4 @@
+import functools
 import string
 from inspect import signature
 from typing import Callable
@@ -15,12 +16,15 @@ class Rule:
     field_type: str
     field_rule: str
     rule_setter: Callable
+    fixed_params: dict
 
-    def __init__(self, field_type: str, field_rule: str, rule_setter: Callable) -> None:
+    def __init__(self, field_type: str, field_rule: str, rule_setter: Callable, fixed_params: dict = None) -> None:
         self.field_type = field_type
         self.field_rule = field_rule
         self.rule_setter = rule_setter
+        self.fixed_params = fixed_params or {}
         self.__validate_rule_function_params()
+        self.__apply_fixed_params()
 
     def __repr__(self):
         return self.field_rule
@@ -39,6 +43,19 @@ class Rule:
         if "self" not in rule_setter_params:
             raise NotAClassMethod()
 
+        rule_setter_params = rule_setter_params - set(self.fixed_params)
         rule_setter_params.remove("self")
         if set(self.rule_params) != rule_setter_params:
-            raise RuleFunctionParamsMismatch(f"Rule Params: {self.rule_params}, Setter Params: {rule_setter_params}")
+            rule_total_params = set(self.rule_params).union(set(self.fixed_params))
+            raise RuleFunctionParamsMismatch(f"Rule Params: {rule_total_params}, Setter Params: {rule_setter_params}")
+
+    def __apply_fixed_params(self):
+        if not self.fixed_params:
+            return
+        rule_setter_sign = signature(self.rule_setter)
+        all_params = rule_setter_sign.parameters
+
+        for param in self.fixed_params:
+            if param not in all_params:
+                raise ValueError(f"The fixed parameter '{param}' is not in the function '{self.rule_setter.__name__}'.")
+        self.rule_setter = functools.partial(self.rule_setter, **self.fixed_params)

{data_sitter-0.1.3 → data_sitter-0.1.4}/data_sitter/rules/RuleRegistry.py

@@ -17,12 +17,12 @@ class RuleRegistry:
     type_map: Dict[str, Type["BaseField"]] = {}
 
     @classmethod
-    def register_rule(cls, field_rule: str):
+    def register_rule(cls, field_rule: str, fixed_params: dict = None):
         def _register(func: callable):
             field_type, func_name = func.__qualname__.split(".")
             logger.debug("Registering function '%s' for %s. Rule: %s", func_name, field_type, field_rule)
 
-            rule = Rule(field_type, field_rule, func)
+            rule = Rule(field_type, field_rule, func, fixed_params)
             cls.rules[field_type].append(rule)
             logger.debug("Function '%s' Registered", func_name)
             return func
@@ -57,8 +57,8 @@ class RuleRegistry:
         ]
 
 
-def register_rule(rule: str):
-    return RuleRegistry.register_rule(rule)
+def register_rule(rule: str, fixed_params: dict = None):
+    return RuleRegistry.register_rule(rule, fixed_params)
 
 
 def register_field(field_class: type):

{data_sitter-0.1.3 → data_sitter-0.1.4}/data_sitter.egg-info/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.2
 Name: data-sitter
-Version: 0.1.3
+Version: 0.1.4
 Summary: A Python library that reads data contracts and generates Pydantic models for seamless data validation.
 Author-email: Lázaro Pereira Candea <lazaro@candea.es>
 Requires-Dist: python-dotenv==1.0.1
+Requires-Dist: PyYAML==6.0.2
 Requires-Dist: parse_type==0.6.4
 Requires-Dist: pydantic==2.10.5

{data_sitter-0.1.3 → data_sitter-0.1.4}/data_sitter.egg-info/requires.txt

@@ -1,3 +1,4 @@
 python-dotenv==1.0.1
+PyYAML==6.0.2
 parse_type==0.6.4
 pydantic==2.10.5

{data_sitter-0.1.3 → data_sitter-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = 'data-sitter'
-version = "0.1.3"
+version = "0.1.4"
 description = "A Python library that reads data contracts and generates Pydantic models for seamless data validation."
 authors = [
     {name = 'Lázaro Pereira Candea', email = 'lazaro@candea.es'},
@@ -12,6 +12,7 @@ authors = [
 dependencies = [
     # Keep this in sync with setup.py
     "python-dotenv==1.0.1",
+    "PyYAML==6.0.2",
     "parse_type==0.6.4",
     "pydantic==2.10.5",
 ]

{data_sitter-0.1.3 → data_sitter-0.1.4}/setup.py

@@ -3,11 +3,12 @@ from setuptools import setup, find_packages
 
 setup(
     name='data-sitter',
-    version='0.1.3',
+    version='0.1.4',
     packages=find_packages(),
     install_requires=[
         # Keep this in sync with pyproject.toml
         "python-dotenv==1.0.1",
+        "PyYAML==6.0.2",
         "parse_type==0.6.4",
         "pydantic==2.10.5",
     ],

data_sitter-0.1.3/data_sitter/Validation.py

@@ -1,30 +0,0 @@
-
-from collections import defaultdict
-from typing import Any, Dict, List, Type
-
-from pydantic import BaseModel, ValidationError
-
-
-class Validation():
-    row: Dict[str, Any]
-    errors: Dict[str, List[str]]
-
-    def __init__(self, row: dict, errors: dict = None):
-        self.row = row
-        self.errors = errors or {}
-
-    def to_dict(self) -> dict:
-        return {"row": self.row, "errors": self.errors}
-    
-    @classmethod
-    def validate(cls, model: Type[BaseModel], item: dict) -> "Validation":
-        try:
-            row = model(**item)  # Validate the row
-            return Validation(row=row.model_dump())
-        except ValidationError as e:
-            errors = defaultdict(list)
-            for error in e.errors():
-                field = error['loc'][0]  # Extract the field name
-                msg = error['msg']
-                errors[field].append(msg)
-            return Validation(row=item, errors=dict(errors))

data_sitter-0.1.3/data_sitter/field_types/FloatField.py

@@ -1,7 +0,0 @@
-from .NumericField import NumericField
-from ..rules import register_field
-
-
-@register_field
-class FloatField(NumericField):
-    field_type = float

data_sitter-0.1.3/data_sitter/field_types/StringField.py

@@ -1,89 +0,0 @@
-from typing import List
-
-from .BaseField import BaseField
-from ..rules import register_rule, register_field
-
-
-@register_field
-class StringField(BaseField):
-    field_type = str
-
-    @register_rule("Is not empty")
-    def validate_not_empty(self):
-        def validator(value: str):
-            if value == "":
-                raise ValueError("The value is empty")
-            return value
-        self.validators.append(validator)
-
-    @register_rule("Starts with {prefix:String}")
-    def validate_starts_with(self, prefix: List[str]):
-        def validator(value: str):
-            if not value.startswith(prefix):
-                raise ValueError(f"The value '{value}' does not start with '{prefix}'.")
-            return value
-        self.validators.append(validator)
-
-    @register_rule("Ends with {sufix:String}")
-    def validate_ends_with(self, sufix: List[str]):
-        def validator(value: str):
-            if not value.endswith(sufix):
-                raise ValueError(f"The value '{value}' does not ends with '{sufix}'.")
-            return value
-        self.validators.append(validator)
-
-    @register_rule("Value in {possible_values:Strings}")
-    def validate_in(self, possible_values: List[str]):
-        def validator(value: str):
-            if value not in possible_values:
-                raise ValueError(f"The value '{value}' is not in the list.")
-            return value
-        self.validators.append(validator)
-
-    @register_rule("Length between {min_val:Integer} and {max_val:Integer}")
-    def validate_length_between(self, min_val: int, max_val: int):
-        def validator(value: str):
-            if not (min_val < len(value) < max_val):
-                raise ValueError(f"Length {len(value)} is not in between {min_val} and {max_val}.")
-            return value
-        self.validators.append(validator)
-
-    @register_rule("Maximum length of {max_len:Integer}")
-    def validate_max_length(self, max_len: int):
-        def validator(value: str):
-            if len(value) > max_len:
-                raise ValueError(f"Length {len(value)} is longer than {max_len}.")
-            return value
-        self.validators.append(validator)
-
-    @register_rule("Length shorter than {max_len:Integer}")
-    def validate_shorter_than(self, max_len: int):
-        def validator(value: str):
-            if len(value) >= max_len:
-                raise ValueError(f"Length {len(value)} is not in shorter than {max_len}.")
-            return value
-        self.validators.append(validator)
-
-    @register_rule("Minimum length of {min_len:Integer}")
-    def validate_min_length(self, min_len: int):
-        def validator(value: str):
-            if len(value) < min_len:
-                raise ValueError(f"Length {len(value)} is shorter than {min_len}.")
-            return value
-        self.validators.append(validator)
-
-    @register_rule("Length longer than {min_len:Integer}")
-    def validate_longer_than(self, min_len: int):
-        def validator(value: str):
-            if len(value) <= min_len:
-                raise ValueError(f"Length {len(value)} is not in longer than {min_len}.")
-            return value
-        self.validators.append(validator)
-
-    @register_rule("Is uppercase")
-    def validate_uppercase(self):
-        def validator(value: str):
-            if not value.isupper():
-                raise ValueError("Not Uppercase")
-            return value
-        self.validators.append(validator)