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

data_sitter/Contract.py

@@ -1,3 +1,5 @@
+import json
+import yaml
 from typing import Any, Dict, List, NamedTuple
 from functools import cached_property
 
@@ -6,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):
@@ -18,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:
@@ -35,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
@@ -52,25 +54,30 @@ 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 = {}
         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)
 
@@ -78,29 +85,45 @@ 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()
             }
         })
 
-    def get_front_end_contract(self):
+    @cached_property
+    def contract(self) -> dict:
+        return {
+            "name": self.name,
+            "fields": [
+                {
+                    "name": name,
+                    "type": field_validator.type_name.value,
+                    "rules": [rule.parsed_rule for rule in self.rules.get(name, [])]
+                }
+                for 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": [
                 {
-                    "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,8 +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
 
 
@@ -10,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
@@ -22,24 +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:
-        is_optional = "Validate Not Null" not in parsed_rules
-        validator = self.field_class(field_name, is_optional)
-        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/Validation.py

@@ -1,4 +1,3 @@
-
 from collections import defaultdict
 from typing import Any, Dict, List, Type
 
@@ -6,25 +5,35 @@ from pydantic import BaseModel, ValidationError
 
 
 class Validation():
-    row: Dict[str, Any]
+    item: Dict[str, Any]
     errors: Dict[str, List[str]]
+    unknowns: Dict[str, Any]
 
-    def __init__(self, row: dict, errors: dict = None):
-        self.row = row
-        self.errors = errors or {}
+    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 {"row": self.row, "errors": self.errors}
-    
+        return {key: value for key in ["item", "errors", "unknowns"] if (value := getattr(self, key))}
+
     @classmethod
-    def validate(cls, model: Type[BaseModel], item: dict) -> "Validation":
+    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:
-            row = model(**item)  # Validate the row
-            return Validation(row=row.model_dump())
+            validated = PydanticModel(**item).model_dump()
         except ValidationError as e:
-            errors = defaultdict(list)
+            validated = item
             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))
+        return Validation(item=validated, errors=dict(errors), unknowns=unknowns)

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,38 +26,42 @@ class BaseField(ABC):
     is_optional: bool
     validators = None
     field_type = None
+    type_name = FieldTypes.BASE
 
-    def __init__(self, name: str, is_optional: bool) -> None:
+    def __init__(self, name: str) -> None:
         self.name = name
-        self.is_optional = is_optional
-        self.validators = []
+        self.is_optional = True
+        self.validators = None
 
-    @register_rule("Validate Not Null")
+    @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")
+                raise ValueError("Value cannot be null.")
             return value
 
-        self.validators.append(_validator)
+        self.is_optional = False
+        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,7 +1,26 @@
+from .FieldTypes import FieldTypes
 from .NumericField import NumericField
-from ..rules import register_field
+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):
+            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
+        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,67 +10,72 @@ Numeric = Union[int, float]
 @register_field
 class NumericField(BaseField):
     field_type = Numeric
+    type_name = FieldTypes.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)
+        return 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")
+            if value <= 0:
+                raise ValueError("Value must be positive.")
             return value
-        self.validators.append(validator)
+        return 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)
+        return 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)
+        return 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)
+        return 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)
+        return 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)
+        return 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)
+        return validator