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

data_sitter/Contract.py

@@ -8,7 +8,7 @@ from pydantic import BaseModel
 from .Validation import Validation
 from .field_types import BaseField
 from .FieldResolver import FieldResolver
-from .rules import MatchedRule, RuleRegistry, RuleParser
+from .rules import ProcessedRule, RuleRegistry, RuleParser
 
 
 class ContractWithoutFields(Exception):
@@ -20,9 +20,9 @@ class ContractWithoutName(Exception):
 
 
 class Field(NamedTuple):
-    field_name: str
-    field_type: str
-    field_rules: List[str]
+    name: str
+    type: str
+    rules: List[str]
 
 
 class Contract:
@@ -37,8 +37,8 @@ class Contract:
         self.fields = fields
         self.rule_parser = RuleParser(values)
         self.field_resolvers = {
-            field_type: FieldResolver(RuleRegistry.get_type(field_type), self.rule_parser)
-            for field_type in list({field.field_type for field in self.fields})  # Unique types
+            _type: FieldResolver(RuleRegistry.get_type(_type), self.rule_parser)
+            for _type in list({field.type for field in self.fields})  # Unique types
         }
 
     @classmethod
@@ -66,21 +66,18 @@ class Contract:
     def field_validators(self) -> Dict[str, BaseField]:
         field_validators = {}
         for field in self.fields:
-            field_resolver = self.field_resolvers[field.field_type]
-            field_validators[field.field_name] = field_resolver.get_field_validator(field.field_name, field.field_rules)
+            field_resolver = self.field_resolvers[field.type]
+            field_validators[field.name] = field_resolver.get_field_validator(field.name, field.rules)
         return field_validators
 
     @cached_property
-    def rules(self) -> Dict[str, List[MatchedRule]]:
+    def rules(self) -> Dict[str, List[ProcessedRule]]:
         rules = {}
         for field in self.fields:
-            field_resolver = self.field_resolvers[field.field_type]
-            rules[field.field_name] = field_resolver.get_matched_rules(field.field_rules)
+            field_resolver = self.field_resolvers[field.type]
+            rules[field.name] = field_resolver.get_processed_rules(field.rules)
         return rules
 
-    def model_validate(self, item: dict):
-        return self.pydantic_model.model_validate(item).model_dump()
-
     def validate(self, item: dict) -> Validation:
         return Validation.validate(self.pydantic_model, item)
 
@@ -88,8 +85,8 @@ class Contract:
     def pydantic_model(self) -> BaseModel:
         return type(self.name, (BaseModel,), {
             "__annotations__": {
-                field_name: field_validator.get_annotation()
-                for field_name, field_validator in self.field_validators.items()
+                name: field_validator.get_annotation()
+                for name, field_validator in self.field_validators.items()
             }
         })
 
@@ -99,11 +96,11 @@ class Contract:
             "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, [])]
+                    "name": name,
+                    "type": field_validator.type_name.value,
+                    "rules": [rule.parsed_rule for rule in self.rules.get(name, [])]
                 }
-                for field_name, field_validator in self.field_validators.items()
+                for name, field_validator in self.field_validators.items()
             ],
             "values": self.rule_parser.values
         }
@@ -119,19 +116,14 @@ class Contract:
             "name": self.name,
             "fields": [
                 {
-                    "field_name": field_name,
-                    "field_type": field_validator.__class__.__name__,
-                    "field_rules": [
-                        {
-                            "rule": rule.field_rule,
-                            "parsed_rule": rule.parsed_rule,
-                            "rule_params": rule.rule_params,
-                            "parsed_values": rule.parsed_values,
-                        }
-                        for rule in self.rules.get(field_name, [])
+                    "name": name,
+                    "type": field_validator.type_name.value,
+                    "rules": [
+                        rule.get_front_end_repr()
+                        for rule in self.rules.get(name, [])
                     ]
                 }
-                for field_name, field_validator in self.field_validators.items()
+                for name, field_validator in self.field_validators.items()
             ],
             "values": self.rule_parser.values
         }

data_sitter/FieldResolver.py

@@ -1,7 +1,7 @@
-from typing import  Dict, List, Type
+from typing import  Dict, List, Type, Union
 
 from .field_types import BaseField
-from .rules import MatchedRule, Rule, RuleRegistry
+from .rules import Rule, ProcessedRule, LogicalRule, MatchedRule, RuleRegistry, LogicalOperator
 from .rules.Parser import RuleParser
 
 
@@ -9,6 +9,10 @@ class RuleNotFoundError(Exception):
     """No matching rule found for the given parsed rule."""
 
 
+class MalformedLogicalRuleError(Exception):
+    """Logical rule structure not recognised."""
+
+
 class FieldResolver:
     field_class: Type[BaseField]
     rule_parser: RuleParser
@@ -21,23 +25,32 @@ class FieldResolver:
         self.rules = RuleRegistry.get_rules_for(field_class)
         self._match_rule_cache = {}
 
-    def get_matched_rules(self, parsed_rules: List[str]) -> List[MatchedRule]:
-        matched_rules = []
+    def get_field_validator(self, name: str, parsed_rules: List[Union[str, dict]]) -> BaseField:
+        field_validator = self.field_class(name)
+        processed_rules = self.get_processed_rules(parsed_rules)
+        validators = [pr.get_validator(field_validator) for pr in processed_rules]
+        field_validator.validators = validators
+        return field_validator
+
+    def get_processed_rules(self, parsed_rules: List[Union[str, dict]]) -> List[ProcessedRule]:
+        processed_rules = []
         for parsed_rule in parsed_rules:
-            matched_rule = self.match_rule(parsed_rule)
-            if not matched_rule:
-                raise RuleNotFoundError(f"Rule not found for parsed rule: '{parsed_rule}'")
-            matched_rules.append(matched_rule)
-        return matched_rules
-
-    def get_field_validator(self, field_name: str, parsed_rules: List[str]) -> BaseField:
-        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)
-        return validator
-
-    def match_rule(self, parsed_rule: str) -> MatchedRule:
+            if isinstance(parsed_rule, dict):
+                if len(keys := tuple(parsed_rule)) != 1 or (operator := keys[0]) not in LogicalOperator:
+                    raise MalformedLogicalRuleError()
+                if operator == LogicalOperator.NOT and not isinstance(parsed_rule[operator], list):
+                    parsed_rule = {operator: [parsed_rule[operator]]}  # NOT operator can be a single rule
+                processed_rule = LogicalRule(operator, self.get_processed_rules(parsed_rule[operator]))
+            elif isinstance(parsed_rule, str):
+                processed_rule = self._match_rule(parsed_rule)
+                if not processed_rule:
+                    raise RuleNotFoundError(f"Rule not found for parsed rule: '{parsed_rule}'")
+            else:
+                raise TypeError(f'Parsed Rule type not recognised: {type(parsed_rule)}')
+            processed_rules.append(processed_rule)
+        return processed_rules
+
+    def _match_rule(self, parsed_rule: str) -> MatchedRule:
         if parsed_rule in self._match_rule_cache:
             return self._match_rule_cache[parsed_rule]
 

data_sitter/cli.py

@@ -44,5 +44,5 @@ def main():
     print(f"The file {args.file} pass the contract {args.contract}")
 
 
-if __name__ == '__main__':
+if __name__ == '__main__':  # pragma: no cover
     main()

data_sitter/field_types/BaseField.py

@@ -1,18 +1,24 @@
 from abc import ABC
-from typing import Annotated, List, Optional, Type
+from typing import Annotated, Callable, List, Optional, Type
 
 from pydantic import AfterValidator
+
+from .FieldTypes import FieldTypes
 from ..rules import register_rule, register_field
 
 
-def aggregated_validator(validators: List[callable], is_optional: bool):
-    def _validator(value):
+class NotInitialisedError(Exception):
+    """The field instance is initialised without validators"""
+
+
+def aggregated_validator(validators: List[Callable], is_optional: bool):
+    def validator(value):
         if is_optional and value is None:
             return value
         for validator_func in validators:
             validator_func(value)
         return value
-    return _validator
+    return validator
 
 @register_field
 class BaseField(ABC):
@@ -20,39 +26,42 @@ class BaseField(ABC):
     is_optional: bool
     validators = None
     field_type = None
+    type_name = FieldTypes.BASE
 
     def __init__(self, name: str) -> None:
         self.name = name
         self.is_optional = True
-        self.validators = []
+        self.validators = None
 
     @register_rule("Is not null")
     def validator_not_null(self):
-        def _validator(value):
-            if self.is_optional:
-                return value
+        def validator(value):
             if value is None:
                 raise ValueError("Value cannot be null.")
             return value
 
         self.is_optional = False
-        self.validators.append(_validator)
+        return validator
 
     def validate(self, value):
+        if self.validators is None:
+            raise NotInitialisedError()
         for validator in self.validators:
             validator(value)
 
     def get_annotation(self):
+        if self.validators is None:
+            raise NotInitialisedError()
         field_type = Optional[self.field_type] if self.is_optional else self.field_type
         return Annotated[field_type, AfterValidator(aggregated_validator(self.validators, self.is_optional))]
 
     @classmethod
     def get_parents(cls: Type["BaseField"]) -> List[Type["BaseField"]]:
-        if cls.__name__ == "BaseField":
+        if cls == BaseField:
             return []
-        ancestors = []
+        ancestors = set()
         for base in cls.__bases__:
-            if base.__name__.endswith("Field"):
-                ancestors.append(base)
-                ancestors.extend(base.get_parents())  # It wont break because we have a base case
-        return ancestors
+            if issubclass(base, BaseField):
+                ancestors.add(base)
+                ancestors.update(base.get_parents())
+        return list(ancestors)

data_sitter/field_types/FieldTypes.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class FieldTypes(StrEnum):
+    BASE = "Base"
+    INT = "Integer"
+    FLOAT = "Float"
+    STRING = "String"
+    NUMERIC = "Numeric"

data_sitter/field_types/FloatField.py

@@ -1,17 +1,26 @@
+from .FieldTypes import FieldTypes
 from .NumericField import NumericField
 from ..rules import register_field, register_rule
+from decimal import Decimal
 
 
 @register_field
 class FloatField(NumericField):
     field_type = float
+    type_name = FieldTypes.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:
+            decimal_str = str(Decimal(str(value)).normalize())
+            # If no decimal point or only zeros after decimal, it has 0 decimal places
+            if '.' not in decimal_str:
+                decimal_places_count = 0
+            else:
+                decimal_places_count = len(decimal_str.split('.')[1])
+
+            if decimal_places_count > decimal_places:
                 raise ValueError(f"Value must have at most {decimal_places} decimal places.")
             return value
-        self.validators.append(validator)
+        return validator

data_sitter/field_types/IntegerField.py

@@ -1,3 +1,4 @@
+from .FieldTypes import FieldTypes
 from .NumericField import NumericField
 from ..rules import register_field
 
@@ -5,3 +6,4 @@ from ..rules import register_field
 @register_field
 class IntegerField(NumericField):
     field_type = int
+    type_name = FieldTypes.INT

data_sitter/field_types/NumericField.py

@@ -1,6 +1,7 @@
 from typing import Union
 
 from .BaseField import BaseField
+from .FieldTypes import FieldTypes
 from ..rules import register_rule, register_field
 
 Numeric = Union[int, float]
@@ -9,6 +10,7 @@ Numeric = Union[int, float]
 @register_field
 class NumericField(BaseField):
     field_type = Numeric
+    type_name = FieldTypes.NUMERIC
 
     @register_rule("Is not zero")
     def validate_non_zero(self):
@@ -16,15 +18,15 @@ class NumericField(BaseField):
             if value == 0:
                 raise ValueError("Value cannot be zero.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Is positive")
     def validate_positive(self):
         def validator(value: Numeric):
-            if value < 0:
+            if value <= 0:
                 raise ValueError("Value must be positive.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Is negative")
     def validate_negative(self):
@@ -32,7 +34,7 @@ class NumericField(BaseField):
             if value >= 0:
                 raise ValueError("Value must be less than zero.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Is at least {min_val:Number}")
     def validate_min(self, min_val: Numeric):
@@ -40,7 +42,7 @@ class NumericField(BaseField):
             if value < min_val:
                 raise ValueError(f"Value must be at least {min_val}.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Is at most {max_val:Number}")
     def validate_max(self, max_val: Numeric):
@@ -48,7 +50,7 @@ class NumericField(BaseField):
             if value > max_val:
                 raise ValueError(f"Value must not exceed {max_val}.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Is greater than {threshold:Number}")
     def validate_greater_than(self, threshold: Numeric):
@@ -56,7 +58,7 @@ class NumericField(BaseField):
             if value <= threshold:
                 raise ValueError(f"Value must be greater than {threshold}.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Is less than {threshold:Number}")
     def validate_less_than(self, threshold: Numeric):
@@ -64,7 +66,7 @@ class NumericField(BaseField):
             if value >= threshold:
                 raise ValueError(f"Value must be less than {threshold}.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @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})
@@ -76,4 +78,4 @@ class NumericField(BaseField):
             if not condition and not negative:
                 raise ValueError(f"Value must be between {min_val} and {max_val}.")
             return value
-        self.validators.append(validator)
+        return validator

data_sitter/field_types/StringField.py

@@ -2,12 +2,14 @@ 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):
@@ -15,7 +17,7 @@ class StringField(BaseField):
             if value == "":
                 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]):
@@ -23,7 +25,7 @@ class StringField(BaseField):
             if not value.startswith(prefix):
                 raise ValueError(f"Value must start with '{prefix}'.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Ends with {suffix:String}")
     def validate_ends_with(self, suffix: List[str]):
@@ -31,7 +33,7 @@ class StringField(BaseField):
             if not value.endswith(suffix):
                 raise ValueError(f"Value must end with '{suffix}'.")
             return value
-        self.validators.append(validator)
+        return 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})
@@ -43,7 +45,7 @@ class StringField(BaseField):
             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("Has length between {min_val:Integer} and {max_val:Integer}")
     def validate_length_between(self, min_val: int, max_val: int):
@@ -51,7 +53,7 @@ class StringField(BaseField):
             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)
+        return validator
 
     @register_rule("Has maximum length {max_len:Integer}")
     def validate_max_length(self, max_len: int):
@@ -59,7 +61,7 @@ class StringField(BaseField):
             if len(value) > max_len:
                 raise ValueError(f"Length must not exceed {max_len} characters.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Has minimum length {min_len:Integer}")
     def validate_min_length(self, min_len: int):
@@ -67,7 +69,7 @@ class StringField(BaseField):
             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("Is uppercase")
     def validate_uppercase(self):
@@ -75,7 +77,7 @@ class StringField(BaseField):
             if not value.isupper():
                 raise ValueError("Value must be in uppercase.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Is lowercase")
     def validate_lowercase(self):
@@ -83,7 +85,7 @@ class StringField(BaseField):
             if not value.islower():
                 raise ValueError("Value must be in lowercase.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Matches regex {pattern:String}")
     def validate_matches_regex(self, pattern: str):
@@ -91,7 +93,7 @@ class StringField(BaseField):
             if not re.match(pattern, value):
                 raise ValueError(f"Value does not match the required pattern {pattern}.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Is valid email")
     def validate_email(self):
@@ -101,7 +103,7 @@ class StringField(BaseField):
             if not re.match(EMAIL_REGEX, value):
                 raise ValueError("Invalid email format.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Is valid URL")
     def validate_url(self):
@@ -111,7 +113,7 @@ class StringField(BaseField):
             if not re.match(URL_REGEX, value):
                 raise ValueError("Invalid URL format.")
             return value
-        self.validators.append(validator)
+        return validator
 
     @register_rule("Has no digits")
     def validate_no_digits(self):
@@ -119,4 +121,4 @@ class StringField(BaseField):
             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/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, 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)
+class RuleMetadata(NamedTuple):
+    rule: str
+    fixed_params: dict
 
-            rule = Rule(field_type, field_rule, func, fixed_params)
-            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, fixed_params: dict = None):
-    return RuleRegistry.register_rule(rule, fixed_params)
+    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
 
 

data_sitter-0.1.6.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: data-sitter
+Version: 0.1.6
+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-Python: >=3.8
+Description-Content-Type: text/markdown
+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
+Provides-Extra: dev
+Requires-Dist: pytest==8.3.5; extra == "dev"
+Requires-Dist: pytest-cov==6.0.0; extra == "dev"
+Requires-Dist: pytest-mock==3.14.0; extra == "dev"
+Requires-Dist: twine==6.1.0; extra == "dev"
+Requires-Dist: build==1.2.2.post1; extra == "dev"
+
+# Data-Sitter
+
+![Coverage](./coverage.svg)
+
+## Overview
+
+Data-Sitter is a Python library designed to simplify data validation by converting data contracts into Pydantic models. This allows for easy and efficient validation of structured data, ensuring compliance with predefined rules and constraints.
+
+## Features
+
+- Define structured data contracts in JSON format.
+- Generate Pydantic models automatically from contracts.
+- Enforce validation rules at the field level.
+- Support for rule references within the contract.
+
+## Installation
+
+```sh
+pip install data-sitter
+```
+
+## Development and Deployment
+
+### CI/CD Pipeline
+
+The project uses GitHub Actions for continuous integration and deployment:
+
+1. **Pull Request Checks**
+   - Automatically checks if the version has been bumped in `pyproject.toml`
+   - Fails if the version is the same as in the main branch
+   - Ensures every PR includes a version update
+
+2. **Automatic Releases**
+   - When code is merged to the main branch:
+     - Builds the package
+     - Publishes to PyPI automatically
+   - Uses PyPI API token for secure authentication
+
+To set up the CI/CD pipeline:
+
+1. Create a PyPI API token:
+   - Go to [PyPI Account Settings](https://pypi.org/manage/account/)
+   - Create a new API token with "Upload" scope
+   - Copy the token
+
+2. Add the token to GitHub:
+   - Go to your repository's Settings > Secrets and variables > Actions
+   - Create a new secret named `PYPI_API_TOKEN`
+   - Paste your PyPI API token
+
+### Setting Up Development Environment
+
+To set up a development environment with all the necessary tools, install the package with development dependencies:
+
+```sh
+pip install -e ".[dev]"
+```
+
+This will install:
+- The package in editable mode
+- Testing tools (pytest, pytest-cov, pytest-mock)
+- Build tools (build, twine)
+
+### Building the Package
+
+To build the package, run:
+
+```sh
+python -m build
+```
+
+This will create a `dist` directory containing both a source distribution (`.tar.gz`) and a wheel (`.whl`).
+
+### Deploying to PyPI
+
+To upload to PyPI:
+
+```sh
+twine upload dist/*
+```
+
+You'll be prompted for your PyPI username and password. For security, it's recommended to use an API token instead of your password.
+
+## Usage
+
+### Creating a Pydantic Model from a Contract
+
+To convert a data contract into a Pydantic model, follow these steps:
+
+```python
+from data_sitter import Contract
+
+contract_dict = {
+    "name": "test",
+    "fields": [
+        {
+            "name": "FID",
+            "type": "Integer",
+            "rules": ["Positive"]
+        },
+        {
+            "name": "SECCLASS",
+            "type": "String",
+            "rules": [
+                "Validate Not Null",
+                "Value In ['UNCLASSIFIED', 'CLASSIFIED']",
+            ]
+        }
+    ],
+}
+
+contract = Contract.from_dict(contract_dict)
+pydantic_contract = contract.pydantic_model
+```
+
+### Using Rule References
+
+Data-Sitter allows you to define reusable values in the `values` key and reference them in field rules using `$values.[key]`. For example:
+
+```json
+{
+    "name": "example_contract",
+    "fields": [
+        {
+            "name": "CATEGORY",
+            "type": "String",
+            "rules": ["Value In $values.categories"]
+        },
+        {
+            "name": "NAME",
+            "type": "String",
+            "rules": [
+                "Length Between $values.min_length and $values.max_length"
+            ]
+        }
+
+    ],
+    "values": {"categories": ["A", "B", "C"], "min_length": 5,"max_length": 50}
+}
+```
+
+## Available Rules
+
+The available validation rules can be retrieved programmatically:
+
+```python
+from data_sitter import RuleRegistry
+
+rules = RuleRegistry.get_rules_definition()
+print(rules)
+```
+
+### Rule Definitions
+
+Below are the available rules grouped by field type:
+
+#### Base
+
+- Is not null
+
+#### String - (Inherits from `Base`)
+
+- Is not empty
+- 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
+
+#### Numeric - (Inherits from `Base`)
+
+- 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}
+
+#### Integer  - (Inherits from `Numeric`)
+
+#### Float  - (Inherits from `Numeric`)
+
+- 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/lcandea/data-sitter).
+
+## License
+
+Data-Sitter is licensed under the MIT License.

data_sitter-0.1.6.dist-info/RECORD

@@ -0,0 +1,30 @@
+data_sitter/Contract.py,sha256=ykeBA_gr7r7MO4FYvdDrstUzGiq7dyIIipkOZRk8qkA,4042
+data_sitter/FieldResolver.py,sha256=Bh7_MTTO7E87S31dQq3tvkL9E_K-4EDlh3NJSn0eLU0,2732
+data_sitter/Validation.py,sha256=5jdIQZyTrEmXZ_SJP0lq-EEFKrGbYH6z4EQ56oFR7Ck,1474
+data_sitter/__init__.py,sha256=qbE-wU8ELMFwOMG4UTK0lmzn5XF2MK3rc22E8ROgypo,113
+data_sitter/cli.py,sha256=SBmxNC508qt8-C4x2IS6XNZLihtfeALw34QLLYr_p_Q,1686
+data_sitter/field_types/BaseField.py,sha256=2s5wJjz1NoNWvSa-69mMxVf7f5wptuxr6UGVubM6MAQ,1997
+data_sitter/field_types/FieldTypes.py,sha256=ntuguQtLnVon1cB2YvG0p2c1r0zk67qw6o4qfJHxLlY,158
+data_sitter/field_types/FloatField.py,sha256=gHmiSg8Eft57T_J8covrEctMEGa0zuT6R3xJP2UlyIY,945
+data_sitter/field_types/IntegerField.py,sha256=Ll6eool8Rwo2pzyXQz95TjJpzdgW9ShtCK1uHmOi_pQ,213
+data_sitter/field_types/NumericField.py,sha256=uJ6ZB8vJg0xsY1grrVL6k8Heygm1O84fQjEtVg1uJjw,2916
+data_sitter/field_types/StringField.py,sha256=ayxo5d_9xzNR9rAWS6dHNKiRapkFdsCxMtT4K5Qb7ek,4493
+data_sitter/field_types/__init__.py,sha256=GdssttQCJksGcZn7oPM53vOsqOL6R5xRiRJDEtr38Ww,293
+data_sitter/rules/Enums.py,sha256=W-3vXP7NWgkgZexrn8J9EytqZoaWK3EwIX0q5O3QJKY,105
+data_sitter/rules/LogicalRule.py,sha256=4HRPw62HSpmMz_Yr2en4s1eVijlPurPDBHfwSliBS3o,2794
+data_sitter/rules/MatchedRule.py,sha256=DudYNI50EpeIvsFQ7cMpKI1fziBG_yfMPNUZ7OWdygo,2162
+data_sitter/rules/ProcessedRule.py,sha256=5EWjTJ6wgDih1cm8uxJOghLDQs3XK_ywGTGF5hhNly8,640
+data_sitter/rules/Rule.py,sha256=xE31dUwLHD3IzcmPfdqLuXS_rmw-kFdIaCKHvpIArig,2115
+data_sitter/rules/RuleRegistry.py,sha256=1ZMl-5u-6DZ1AGYZA77s6DpAxeN64EFEF-XKVKeQy-U,2698
+data_sitter/rules/__init__.py,sha256=SHQZYp4VNzuygP-ZPegEXwmgj-_oUqEchi9TdbasA6U,465
+data_sitter/rules/Parser/RuleParser.py,sha256=7biF5N3Cf3Rf5bgB4pXUpBaZ4r5EL1I9YHvSTjdydBA,2127
+data_sitter/rules/Parser/__init__.py,sha256=F8qJ7luwq0C65e7pNOzBHB2sF1lMcvIFYfDNJj6XQTc,205
+data_sitter/rules/Parser/alias_parameters_parser.py,sha256=xUgOFJCm42w1eUmZOQ2OsOhCsKGHev5g4gsm_kizciA,1529
+data_sitter/rules/Parser/parser_utils.py,sha256=ypI021uYJTsHAoKGShAfnhd5xQGtqqTGTHozleefsLQ,642
+data_sitter/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+data_sitter/utils/logger_config.py,sha256=fBbDNZOsmDnO6TtLHI1tty4EXi2AnbrA-OgkhXcm1Aw,1235
+data_sitter-0.1.6.dist-info/METADATA,sha256=H3QVZTUxe4F2FtWVEhe0JEmlgZG4n8krQCyBqp5XgdQ,5597
+data_sitter-0.1.6.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+data_sitter-0.1.6.dist-info/entry_points.txt,sha256=1I7xxqFZvA78wmDx7NGavttAb8JFWM3Wxgehftx_5C4,53
+data_sitter-0.1.6.dist-info/top_level.txt,sha256=Q7N21PYeqIdRbDvZQCJXhbbv0PFIf876gu1_DpInH_E,12
+data_sitter-0.1.6.dist-info/RECORD,,

{data_sitter-0.1.4.dist-info → data_sitter-0.1.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

data_sitter-0.1.4.dist-info/METADATA

@@ -1,9 +0,0 @@
-Metadata-Version: 2.2
-Name: data-sitter
-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.4.dist-info/RECORD

@@ -1,26 +0,0 @@
-data_sitter/Contract.py,sha256=ow6CdT7XRbxBy4tY5av3_L9d8qv59nw70ih-jVMKlBU,4561
-data_sitter/FieldResolver.py,sha256=0XSA-doOY4cM_Ikd09hUxykYZOLR5pHwkbNiTmdtweQ,1819
-data_sitter/Validation.py,sha256=5jdIQZyTrEmXZ_SJP0lq-EEFKrGbYH6z4EQ56oFR7Ck,1474
-data_sitter/__init__.py,sha256=qbE-wU8ELMFwOMG4UTK0lmzn5XF2MK3rc22E8ROgypo,113
-data_sitter/cli.py,sha256=1ICrtokqV5RvvWhzWKAeS5ZUSUpiviQyy2JSK71ER10,1666
-data_sitter/field_types/BaseField.py,sha256=mCEy9hFhwus1gW1P6ctbUCUrZ9rJMtreOvfiy9MkO5Q,1799
-data_sitter/field_types/FloatField.py,sha256=75zYGwI65GYIiZWgb5cwb3QoWukp3X-YcrmqhIxOe1w,675
-data_sitter/field_types/IntegerField.py,sha256=o__5z3bg6wsx7FIfJbBYZW5b760-WSZw_05J-OSKXR0,147
-data_sitter/field_types/NumericField.py,sha256=s8aEkk42HYY30citCaBjIynLGfKE7gPayvVq3fdVd2Y,2981
-data_sitter/field_types/StringField.py,sha256=wXlfCTPGPDr2j_lHW6LqtAFKNBoff6nk0tE5Xt02xsQ,4645
-data_sitter/field_types/__init__.py,sha256=GdssttQCJksGcZn7oPM53vOsqOL6R5xRiRJDEtr38Ww,293
-data_sitter/rules/MatchedRule.py,sha256=uHXuo7Np-Bq7IOHaHMYFmYFPRT8aYDEKCdFKcvWf4DM,1946
-data_sitter/rules/Rule.py,sha256=xE31dUwLHD3IzcmPfdqLuXS_rmw-kFdIaCKHvpIArig,2115
-data_sitter/rules/RuleRegistry.py,sha256=iqxcbzypk-_S4ukASNjEe9TD7J-f2psXWR0GVOPlK0E,2134
-data_sitter/rules/__init__.py,sha256=_cTO0SUkW_WW2VBx2NGd8n5TUio7gptkBr9MorW2ZZk,289
-data_sitter/rules/Parser/RuleParser.py,sha256=7biF5N3Cf3Rf5bgB4pXUpBaZ4r5EL1I9YHvSTjdydBA,2127
-data_sitter/rules/Parser/__init__.py,sha256=F8qJ7luwq0C65e7pNOzBHB2sF1lMcvIFYfDNJj6XQTc,205
-data_sitter/rules/Parser/alias_parameters_parser.py,sha256=jsx_JWzkA4lY2nq4hzc4fG7_nnh7yLxmVj6WIP1Mm68,1933
-data_sitter/rules/Parser/parser_utils.py,sha256=ypI021uYJTsHAoKGShAfnhd5xQGtqqTGTHozleefsLQ,642
-data_sitter/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-data_sitter/utils/logger_config.py,sha256=w9E4jWfGJnkC9tZz4qrolSqglKm4jEB8l6vjC-qfj8A,1215
-data_sitter-0.1.4.dist-info/METADATA,sha256=dKf83KLklS2JXoiWJCcEBGi6EqKYUcVn5XPXoL-bQBc,353
-data_sitter-0.1.4.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-data_sitter-0.1.4.dist-info/entry_points.txt,sha256=1I7xxqFZvA78wmDx7NGavttAb8JFWM3Wxgehftx_5C4,53
-data_sitter-0.1.4.dist-info/top_level.txt,sha256=Q7N21PYeqIdRbDvZQCJXhbbv0PFIf876gu1_DpInH_E,12
-data_sitter-0.1.4.dist-info/RECORD,,