data-sitter 0.1.3__py3-none-any.whl → 0.1.6__py3-none-any.whl

data_sitter/field_types/StringField.py

@@ -1,89 +1,124 @@
+import re
 from typing import List
 
 from .BaseField import BaseField
+from .FieldTypes import FieldTypes
 from ..rules import register_rule, register_field
 
 
 @register_field
 class StringField(BaseField):
     field_type = str
+    type_name = FieldTypes.STRING
 
     @register_rule("Is not empty")
     def validate_not_empty(self):
         def validator(value: str):
             if value == "":
-                raise ValueError("The value is empty")
+                raise ValueError("String cannot be empty.")
             return value
-        self.validators.append(validator)
+        return 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}'.")
+                raise ValueError(f"Value must start with '{prefix}'.")
             return value
-        self.validators.append(validator)
+        return validator
 
-    @register_rule("Ends with {sufix:String}")
-    def validate_ends_with(self, sufix: List[str]):
+    @register_rule("Ends with {suffix:String}")
+    def validate_ends_with(self, suffix: List[str]):
         def validator(value: str):
-            if not value.endswith(sufix):
-                raise ValueError(f"The value '{value}' does not ends with '{sufix}'.")
+            if not value.endswith(suffix):
+                raise ValueError(f"Value must end with '{suffix}'.")
             return value
-        self.validators.append(validator)
+        return validator
 
-    @register_rule("Value in {possible_values:Strings}")
-    def validate_in(self, possible_values: List[str]):
+    @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):
-            if value not in possible_values:
-                raise ValueError(f"The value '{value}' is not in the list.")
+            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)
+        return validator
 
-    @register_rule("Length between {min_val:Integer} and {max_val:Integer}")
+    @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 {len(value)} is not in between {min_val} and {max_val}.")
+                raise ValueError(f"Length must be between {min_val} and {max_val} characters.")
             return value
-        self.validators.append(validator)
+        return validator
 
-    @register_rule("Maximum length of {max_len:Integer}")
+    @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 {len(value)} is longer than {max_len}.")
+                raise ValueError(f"Length must not exceed {max_len} characters.")
             return value
-        self.validators.append(validator)
+        return validator
 
-    @register_rule("Length shorter than {max_len:Integer}")
-    def validate_shorter_than(self, max_len: int):
+    @register_rule("Has minimum length {min_len:Integer}")
+    def validate_min_length(self, min_len: int):
         def validator(value: str):
-            if len(value) >= max_len:
-                raise ValueError(f"Length {len(value)} is not in shorter than {max_len}.")
+            if len(value) < min_len:
+                raise ValueError(f"Length must be at least {min_len} characters.")
             return value
-        self.validators.append(validator)
+        return validator
 
-    @register_rule("Minimum length of {min_len:Integer}")
-    def validate_min_length(self, min_len: int):
+    @register_rule("Is uppercase")
+    def validate_uppercase(self):
         def validator(value: str):
-            if len(value) < min_len:
-                raise ValueError(f"Length {len(value)} is shorter than {min_len}.")
+            if not value.isupper():
+                raise ValueError("Value must be in uppercase.")
             return value
-        self.validators.append(validator)
+        return validator
 
-    @register_rule("Length longer than {min_len:Integer}")
-    def validate_longer_than(self, min_len: int):
+    @register_rule("Is lowercase")
+    def validate_lowercase(self):
         def validator(value: str):
-            if len(value) <= min_len:
-                raise ValueError(f"Length {len(value)} is not in longer than {min_len}.")
+            if not value.islower():
+                raise ValueError("Value must be in lowercase.")
             return value
-        self.validators.append(validator)
+        return validator
 
-    @register_rule("Is uppercase")
-    def validate_uppercase(self):
+    @register_rule("Matches regex {pattern:String}")
+    def validate_matches_regex(self, pattern: str):
         def validator(value: str):
-            if not value.isupper():
-                raise ValueError("Not Uppercase")
+            if not re.match(pattern, value):
+                raise ValueError(f"Value does not match the required pattern {pattern}.")
+            return value
+        return 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
+        return 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
+        return 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)
+        return validator

data_sitter/rules/Enums.py

@@ -0,0 +1,7 @@
+from enum import StrEnum
+
+
+class LogicalOperator(StrEnum):
+    AND = "AND"
+    OR = "OR"
+    NOT = "NOT"

data_sitter/rules/LogicalRule.py

@@ -0,0 +1,68 @@
+from typing import TYPE_CHECKING, Callable, List
+
+from .Enums import LogicalOperator
+from .ProcessedRule import ProcessedRule, LogicalParsedRule
+
+if TYPE_CHECKING:  # pragma: no cover
+    from ..field_types import BaseField
+
+
+def and_or_validator(validators: List[Callable], operator: LogicalOperator) -> Callable:
+    def validator(value):
+        exceptions = []
+        for validator_ in validators:
+            try:
+                validator_(value)
+                exceptions.append(None)  # No error, validation passed
+            except Exception as e:
+                exceptions.append(str(e))  # Store error message
+
+        if operator == LogicalOperator.OR and all(exceptions):
+            raise ValueError(f"None of the conditions were met. Errors: {exceptions}")
+        if operator == LogicalOperator.AND and any(exceptions):
+            exceptions = list(filter(None, exceptions))
+            raise ValueError(f"Not all conditions were met. Errors: {exceptions}")
+        return value
+    return validator
+
+
+def not_validator(validator_: Callable):
+    def validator(value):
+        try:
+            validator_(value)
+        except Exception:
+            return value  # Validation passes if the condition fails
+        else:
+            raise ValueError("Condition was met, but expected NOT to be met.")
+    return validator
+
+
+
+class LogicalRule(ProcessedRule):
+    operator: LogicalOperator
+    processed_rules: List[ProcessedRule]
+
+    def __init__(self, operator: LogicalOperator, processed_rules: List[ProcessedRule]):
+        if operator not in LogicalOperator:
+            raise TypeError(f'Logical Operator not recognised: {operator}')
+        if not processed_rules:
+            raise ValueError("Logical rules must have at least one rule.")
+        if operator == LogicalOperator.NOT and len(processed_rules) != 1:
+            raise TypeError(f'Not Operator can only contain one rule. Cotains: {len(processed_rules)}')
+        self.operator = operator
+        self.processed_rules = processed_rules
+
+    @property
+    def parsed_rule(self) -> LogicalParsedRule:
+        return {self.operator: [pr.parsed_rule for pr in self.processed_rules]}
+
+    def get_validator(self, field_instance: "BaseField") -> Callable:
+        if self.operator in (LogicalOperator.OR, LogicalOperator.AND):
+            return and_or_validator([pr.get_validator(field_instance) for pr in self.processed_rules], self.operator)
+        elif self.operator == LogicalOperator.NOT:
+            return not_validator(self.processed_rules[0].get_validator(field_instance))
+        else:
+            raise TypeError(f'Logical Operator not recognised: {self.operator}')
+
+    def get_front_end_repr(self) -> dict:
+        return {self.operator: [pr.get_front_end_repr() for pr in self.processed_rules]}

data_sitter/rules/MatchedRule.py

@@ -1,23 +1,20 @@
-from typing import TYPE_CHECKING, Any, Dict
+from typing import TYPE_CHECKING, Any, Callable, Dict
 
 from .Rule import Rule
 from .RuleRegistry import RuleRegistry
+from .ProcessedRule import ProcessedRule, MatchedParsedRule
 from .Parser.parser_utils import get_value_from_reference
 
-if TYPE_CHECKING:
-    from field_types import BaseField
+if TYPE_CHECKING:  # pragma: no cover
+    from ..field_types import BaseField
 
 
 class RuleParsedValuesMismatch(Exception):
     pass
 
 
-class InvalidFieldTypeError(TypeError):
-    """Raised when attempting to add a rule to an incompatible field type."""
-
-
-class MatchedRule(Rule):
-    parsed_rule: str
+class MatchedRule(ProcessedRule):
+    parsed_rule: MatchedParsedRule
     parsed_values: Dict[str, Any]
     values: Dict[str, Any]
 
@@ -48,10 +45,16 @@ class MatchedRule(Rule):
         if set(self.rule_params) != parsed_values_values:
             raise RuleParsedValuesMismatch(f"Rule Params: {self.rule_params}, Parsed Values: {parsed_values_values}")
 
-    def add_to_instance(self, field_instance: "BaseField"):
+    def get_validator(self, field_instance: "BaseField") -> Callable:
         field_class = RuleRegistry.get_type(self.field_type)
         if not isinstance(field_instance, field_class):
-            raise InvalidFieldTypeError(
-                f"Cannot add rule to {type(field_instance).__name__}, expected {self.field_type}."
-            )
-        self.rule_setter(self=field_instance, **self.resolved_values)
+            raise TypeError(f"Cannot add rule to {type(field_instance).__name__}, expected {self.field_type}.")
+        return self.rule_setter(self=field_instance, **self.resolved_values)
+
+    def get_front_end_repr(self) -> dict:
+        return {
+            "rule": self.field_rule,
+            "parsed_rule": self.parsed_rule,
+            "rule_params": self.rule_params,
+            "parsed_values": self.parsed_values,
+        }

data_sitter/rules/Parser/alias_parameters_parser.py

@@ -56,23 +56,3 @@ alias_parameters_types = {
     "String": parse_string,
     "Strings": parse_array_of("String", parse_string),
 }
-
-
-
-
-
-
-
-# class Store()
-#     pass
-
-
-# values = {"classes": ["UNCLASSIFIED"], "min_length": 5, "max_length": 50}
-
-
-# alias_parser = Parser("Value in {possible_values:Strings}", extra_types=alias_parameters_types)
-# # print(alias_parser.parse("Value In ['UNCLASSIFIED', 'CLASSIFIED']"))
-
-# with Store(values=values) as store:
-#     print(alias_parser.parse("Value In $values.classes"))
-#     print(store.)

data_sitter/rules/ProcessedRule.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Dict, List, Union
+
+from .Rule import Rule
+from .Enums import LogicalOperator
+
+if TYPE_CHECKING:  # pragma: no cover
+    from ..field_types import BaseField
+
+MatchedParsedRule = str
+LogicalParsedRule = Dict[LogicalOperator, List["ParsedRule"]]
+ParsedRule = Union[MatchedParsedRule, LogicalParsedRule]
+
+
+class ProcessedRule(Rule, ABC):
+    parsed_rule: ParsedRule
+
+    @abstractmethod
+    def get_validator(self, field_instance: "BaseField"):
+        pass  # pragma: no cover
+
+    @abstractmethod
+    def get_front_end_repr(self) -> dict:
+        pass  # pragma: no cover

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/rules/RuleRegistry.py

@@ -1,64 +1,85 @@
 from itertools import chain
-from collections import defaultdict
-from typing import TYPE_CHECKING, Dict, List, Type
+from typing import TYPE_CHECKING, Callable, Dict, List, NamedTuple, Type
+
 
 from .Rule import Rule
 from ..utils.logger_config import get_logger
+from ..field_types.FieldTypes import FieldTypes
 
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from field_types.BaseField import BaseField
 
 logger = get_logger(__name__)
 
 
-class RuleRegistry:
-    rules: Dict[str, List[Rule]] = defaultdict(list)
-    type_map: Dict[str, Type["BaseField"]] = {}
-
-    @classmethod
-    def register_rule(cls, field_rule: str):
-        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)
+class RuleMetadata(NamedTuple):
+    rule: str
+    fixed_params: dict
 
-            rule = Rule(field_type, field_rule, func)
-            cls.rules[field_type].append(rule)
-            logger.debug("Function '%s' Registered", func_name)
-            return func
 
-        return _register
+class RuleRegistry:
+    rules: Dict[str, List[Rule]] = {}
+    type_map: Dict[str, Type["BaseField"]] = {}
 
     @classmethod
     def register_field(cls, field_class: Type["BaseField"]) -> Type["BaseField"]:
-        cls.type_map[field_class.__name__] = field_class
+        field_type_name = field_class.type_name
+        cls.type_map[field_class.type_name] = field_class
+        cls.rules[field_class.type_name] = []
+
+        for method in field_class.__dict__.values():
+            metadata: RuleMetadata = getattr(method, "_rule_metadata", None)
+            if metadata is None:
+                continue
+            rule = Rule(
+                field_type=field_type_name,
+                field_rule=metadata.rule,
+                rule_setter=method,
+                fixed_params=metadata.fixed_params
+            )
+            cls.add_rule(field_class, rule)
         return field_class
 
     @classmethod
-    def get_type(cls, field_type: str) -> Type["BaseField"]:
-        return cls.type_map.get(field_type)
+    def add_rule(cls, field_class: Type["BaseField"], rule: Rule):
+        if field_class.type_name not in cls.rules:
+            raise ValueError(f"Field not registered: {field_class.type_name}")
+        cls.rules[field_class.type_name].append(rule)
+
+    @classmethod
+    def get_type(cls, type_name: str) -> Type["BaseField"]:
+        return cls.type_map.get(type_name)
 
     @classmethod
     def get_rules_for(cls, field_class: Type["BaseField"]):
-        if field_class.__name__ == "BaseField":
-            return cls.rules["BaseField"]
+        if field_class.type_name == FieldTypes.BASE:
+            return cls.rules[FieldTypes.BASE]
         parent_rules = list(chain.from_iterable(cls.get_rules_for(p) for p in field_class.get_parents()))
-        return cls.rules[field_class.__name__] + parent_rules
+        return cls.rules[field_class.type_name] + parent_rules
 
     @classmethod
     def get_rules_definition(cls):
         return [
             {
-                "field": field_name,
-                "parent_field": [p.__name__ for p in field_class.get_parents()],
-                "rules": cls.rules.get(field_name, [])
+                "field": name,
+                "parent_field": [p.type_name for p in field_class.get_parents()],
+                "rules": cls.rules.get(name, [])
             }
-            for field_name, field_class in cls.type_map.items()
+            for name, field_class in cls.type_map.items()
         ]
 
 
-def register_rule(rule: str):
-    return RuleRegistry.register_rule(rule)
+def register_rule(rule: str, fixed_params: dict = None):
+    def _register(func: Callable):
+        setattr(func, "_rule_metadata",
+            RuleMetadata(
+                rule=rule,
+                fixed_params=fixed_params or {}
+            )
+        )
+        return func
+    return _register
 
 
 def register_field(field_class: type):

data_sitter/rules/__init__.py

@@ -1,14 +1,20 @@
 from .Rule import Rule
 from .Parser import RuleParser
+from .Enums import LogicalOperator
 from .MatchedRule import MatchedRule
+from .LogicalRule import LogicalRule
+from .ProcessedRule import ProcessedRule
 from .RuleRegistry import RuleRegistry, register_rule, register_field
 
 
 __all__ = [
     "Rule",
-    "MatchedRule",
     "RuleParser",
+    "MatchedRule",
+    "LogicalRule",
+    "ProcessedRule",
     "RuleRegistry",
     "register_rule",
     "register_field",
+    "LogicalOperator",
 ]

data_sitter/utils/logger_config.py

@@ -11,7 +11,7 @@ DEFAULT_LEVEL = "INFO"
 VALID_LOG_LEVEL = ["CRITICAL", "FATAL", "ERROR", "WARN", "WARNING", "INFO", "DEBUG", "NOTSET"]
 LOG_LEVEL = environ.get("LOG_LEVEL", DEFAULT_LEVEL)
 
-if LOG_LEVEL not in VALID_LOG_LEVEL:
+if LOG_LEVEL not in VALID_LOG_LEVEL:  # pragma: no cover
     LOG_LEVEL = DEFAULT_LEVEL