data-sitter 0.1.0__tar.gz

data_sitter-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.2
+Name: data-sitter
+Version: 0.1.0
+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: parse_type==0.6.4
+Requires-Dist: pydantic==2.10.6

data_sitter-0.1.0/README.md

@@ -0,0 +1,133 @@
+# Data-Sitter
+
+## 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
+
+You can install Data-Sitter directly from GitHub:
+
+```sh
+pip install git+https://github.com/Kenr0t/data-sitter.git@main
+```
+
+## 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": [
+        {
+            "field_name": "FID",
+            "field_type": "IntegerField",
+            "field_rules": ["Positive"]
+        },
+        {
+            "field_name": "SECCLASS",
+            "field_type": "StringField",
+            "field_rules": [
+                "Validate Not Null",
+                "Value In ['UNCLASSIFIED', 'CLASSIFIED']",
+            ]
+        }
+    ],
+}
+
+contract = Contract.from_dict(contract_dict)
+pydantic_contract = contract.get_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": [
+        {
+            "field_name": "CATEGORY",
+            "field_type": "StringField",
+            "field_rules": ["Value In $values.categories"]
+        },
+        {
+            "field_name": "NAME",
+            "field_type": "StringField",
+            "field_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:
+
+#### BaseField
+
+- Validate 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}`
+- Is uppercase
+
+#### 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}`
+
+#### IntegerField  - (Inherits from `NumericField`)
+
+#### FloatField  - (Inherits from `NumericField`)
+
+## Contributing
+
+Contributions are welcome! Feel free to submit issues or pull requests in the [GitHub repository](https://github.com/Kenr0t/data-sitter).
+
+## License
+
+Data-Sitter is licensed under the MIT License.

data_sitter-0.1.0/data_sitter/Contract.py

@@ -0,0 +1,101 @@
+from typing import Any, Dict, List, NamedTuple
+from functools import cached_property
+
+from pydantic import BaseModel
+
+from .field_types import BaseField
+from .FieldResolver import FieldResolver
+from .rules import MatchedRule, RuleRegistry, RuleParser
+
+
+class ContractWithoutFields(Exception):
+    pass
+
+
+class ContractWithoutName(Exception):
+    pass
+
+
+class Field(NamedTuple):
+    field_name: str
+    field_type: str
+    field_rules: List[str]
+
+
+class Contract:
+    name: str
+    fields: List[Field]
+    rule_parser: RuleParser
+    field_resolvers: Dict[str, FieldResolver]
+
+
+    def __init__(self, name: str, fields: List[Field], values: Dict[str, Any]) -> None:
+        self.name = name
+        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
+        }
+
+    @classmethod
+    def from_dict(cls, contract_dict: dict):
+        if "name" not in contract_dict:
+            raise ContractWithoutName()
+        if "fields" not in contract_dict:
+            raise ContractWithoutFields()
+
+        return cls(
+            name=contract_dict["name"],
+            fields=[Field(**field) for field in contract_dict["fields"]],
+            values=contract_dict.get("values", {}),
+        )
+
+    @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)
+        return field_validators
+
+    @cached_property
+    def rules(self) -> Dict[str, List[MatchedRule]]:
+        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)
+        return rules
+
+    def model_validate(self, item: dict):
+        pydantic_model = self.get_pydantic_model()
+        return pydantic_model.model_validate(item).model_dump()
+
+    def get_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()
+            }
+        })
+
+    def get_front_end_contract(self):
+        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, [])
+                    ]
+                }
+                for field_name, field_validator in self.field_validators.items()
+            ]
+        }

data_sitter-0.1.0/data_sitter/FieldResolver.py

@@ -0,0 +1,50 @@
+
+from typing import  Dict, List, Type
+
+from .field_types import BaseField
+from .rules import MatchedRule, Rule, RuleRegistry
+from .rules.Parser import RuleParser
+
+
+class RuleNotFoundError(Exception):
+    """No matching rule found for the given parsed rule."""
+
+
+class FieldResolver:
+    field_class: Type[BaseField]
+    rule_parser: RuleParser
+    rules: List[Rule]
+    _match_rule_cache: Dict[str, MatchedRule]
+
+    def __init__(self, field_class: Type[BaseField], rule_parser: RuleParser) -> None:
+        self.field_class = field_class
+        self.rule_parser = rule_parser
+        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 = []
+        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 parsed_rule in self._match_rule_cache:
+            return self._match_rule_cache[parsed_rule]
+
+        for rule in self.rules:
+            matched_rule = self.rule_parser.match(rule, parsed_rule)
+            if matched_rule:
+                self._match_rule_cache[parsed_rule] = matched_rule
+                return matched_rule
+        return None

data_sitter-0.1.0/data_sitter/__init__.py

@@ -0,0 +1,7 @@
+from .Contract import Contract
+from .rules import RuleRegistry
+
+__all__ = [
+    "Contract",
+    "RuleRegistry"
+]

data_sitter-0.1.0/data_sitter/cli.py

@@ -0,0 +1,48 @@
+import csv
+import json
+import argparse
+from pathlib import Path
+
+from .Contract import Contract
+
+
+DEFAULT_ENCODING = "utf8"
+
+def main():
+    parser = argparse.ArgumentParser(description='Data Sitter CLI')
+    parser.add_argument('-c', '--contract', required=True, help='Path to contract file')
+    parser.add_argument('-f', '--file', required=True, help='Path to data file')
+    parser.add_argument('-e', '--encoding', help='Files Encoding', default=DEFAULT_ENCODING)
+
+    args = parser.parse_args()
+    # Add your logic here using args.contract and args.file
+    print(f"Processing {args.file} with contract {args.contract}")
+
+    file_path = Path(args.file)
+    encoding = args.encoding
+    contract_path = Path(args.contract)
+    contract_dict = json.loads(contract_path.read_text(encoding))
+    contract = Contract.from_dict(contract_dict)
+    pydantic_contract = contract.get_pydantic_model()
+
+    if file_path.suffix == '.csv':
+        with open(file_path, encoding=encoding) as f:
+            reader = csv.DictReader(f)
+            reader.fieldnames = [name.strip() for name in reader.fieldnames]
+            records = [{k: v.strip() for k, v in row.items()} for row in reader]
+
+    elif file_path.suffix == '.json':
+        file_data = json.loads(file_path.read_text(encoding))
+        if isinstance(file_data, dict):
+            records = [file_data]
+        else:
+            records = file_data
+    else:
+        raise NotImplementedError(f"Type {file_path.suffix} not implemented.")
+
+    _ = [pydantic_contract.model_validate(row) for row in records]
+    print(f"The file {args.file} pass the contract {args.contract}")
+
+
+if __name__ == '__main__':
+    main()

data_sitter-0.1.0/data_sitter/field_types/BaseField.py

@@ -0,0 +1,50 @@
+from abc import ABC
+from typing import Annotated, List, Type
+
+from pydantic import AfterValidator
+from ..rules import register_rule, register_field
+
+
+def aggregated_validator(validators: List[callable]):
+    def _validator(value):
+        for validator_func in validators:
+            validator_func(value)
+        return value
+    return _validator
+
+@register_field
+class BaseField(ABC):
+    name: str
+    validators = None
+    field_type = None
+
+    def __init__(self, name) -> None:
+        self.name = name
+        self.validators = []
+
+    @register_rule("Validate Not Null")
+    def validator_not_null(self):
+        def _validator(value):
+            if value is None:
+                raise ValueError()
+            return value
+
+        self.validators.append(_validator)
+
+    def validate(self, value):
+        for validator in self.validators:
+            validator(value)
+
+    def get_annotation(self):
+        return Annotated[self.field_type, AfterValidator(aggregated_validator(self.validators))]
+
+    @classmethod
+    def get_parents(cls: Type["BaseField"]) -> List[Type["BaseField"]]:
+        if cls.__name__ == "BaseField":
+            return []
+        ancestors = []
+        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

data_sitter-0.1.0/data_sitter/field_types/FloatField.py

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

data_sitter-0.1.0/data_sitter/field_types/IntegerField.py

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

data_sitter-0.1.0/data_sitter/field_types/NumericField.py

@@ -0,0 +1,75 @@
+from typing import Union
+
+from .BaseField import BaseField
+from ..rules import register_rule, register_field
+
+Numeric = Union[int, float]
+
+
+@register_field
+class NumericField(BaseField):
+    field_type = Numeric
+
+    @register_rule("Not Zero")
+    def validate_non_zero(self):
+        def validator(value: Numeric):
+            if value == 0:
+                raise ValueError("Value must not be zero")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Positive")
+    def validate_positive(self):
+        def validator(value: Numeric):
+            if value < 0:
+                raise ValueError(f"Value {value} is not positive")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Negative")
+    def validate_negative(self):
+        def validator(value: Numeric):
+            if value >= 0:
+                raise ValueError(f"Value {value} is not negative")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Minimum {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}")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Maximum {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}")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("Greate 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}")
+            return value
+        self.validators.append(validator)
+
+    @register_rule("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}")
+            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):
+        def validator(value: Numeric):
+            if not (min_val < value < max_val):
+                raise ValueError(f"Value {value} not in Between {min_val} and {max_val}.")
+            return value
+        self.validators.append(validator)

data_sitter-0.1.0/data_sitter/field_types/StringField.py

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

data_sitter-0.1.0/data_sitter/field_types/__init__.py

@@ -0,0 +1,14 @@
+from .BaseField import BaseField
+from .StringField import StringField
+from .NumericField import NumericField
+from .IntegerField import IntegerField
+from .FloatField import FloatField
+
+
+__all__ = [
+    "BaseField",
+    "StringField",
+    "NumericField",
+    "IntegerField",
+    "FloatField",
+]

data_sitter-0.1.0/data_sitter/rules/MatchedRule.py

@@ -0,0 +1,57 @@
+from typing import TYPE_CHECKING, Any, Dict
+
+from .Rule import Rule
+from .RuleRegistry import RuleRegistry
+from .Parser.parser_utils import get_value_from_reference
+
+if TYPE_CHECKING:
+    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
+    parsed_values: Dict[str, Any]
+    values: Dict[str, Any]
+
+    def __init__(self,
+        rule: Rule,
+        parsed_rule: str,
+        parsed_values: Dict[str, Any],
+        values: Dict[str, Any]
+    ):
+        super().__init__(**vars(rule))
+        self.parsed_rule = parsed_rule
+        self.parsed_values = parsed_values
+        self.values = values
+        self.__validate_rule_parsed_values()
+
+    @property
+    def resolved_values(self) -> Dict[str, Any]:
+        resolved = {}
+        for rule_param, param_value in self.parsed_values.items():
+            if isinstance(param_value, str) and param_value.startswith('$'):
+                resolved[rule_param] = get_value_from_reference(param_value, self.values)
+            else:
+                resolved[rule_param] = param_value
+        return resolved
+
+    def __validate_rule_parsed_values(self):
+        parsed_values_values = set(self.parsed_values.keys())
+        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"):
+        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)

data_sitter-0.1.0/data_sitter/rules/Parser/RuleParser.py

@@ -0,0 +1,54 @@
+from typing import Callable, Dict, Optional
+
+from parse import with_pattern, Parser
+from parse_type import TypeBuilder
+
+from .parser_utils import REF_PATTERN, get_value_from_reference, get_key_from_reference
+from .alias_parameters_parser import NotCompatibleTypes, alias_parameters_types
+from ..Rule import Rule
+from ..MatchedRule import MatchedRule
+
+
+CASE_SENSITIVE_RULES = False
+
+
+class RuleParser:
+    values: dict
+    aliases: dict
+    parsers: Dict[str, Parser]
+
+    def __init__(self, values: dict):
+        self.values = values
+        self.parsers = {}
+        self.aliases = self.get_aliases_with_reference_support()
+
+    def match(self, rule: Rule, parsed_rule: str) -> Optional[MatchedRule]:
+        parser = self.get_parser_for_rule(rule)
+        parsed_values = parser.parse(parsed_rule)
+        if parsed_values is None:
+            return
+        return MatchedRule(rule, parsed_rule, parsed_values.named, self.values)
+
+    def get_parser_for_rule(self, rule: Rule) -> Parser:
+        if rule.field_rule not in self.parsers:
+            parser = Parser(rule.field_rule, extra_types=self.aliases, case_sensitive=CASE_SENSITIVE_RULES)
+            self.parsers[rule.field_rule] = parser
+        return self.parsers[rule.field_rule]
+
+    def parse_reference_of(self, type_name: str, type_parser: Callable):
+        _parser = Parser(f"{{value:{type_name}}}", extra_types={type_name: type_parser})
+
+        def parse_reference(text):
+            reference_value = get_value_from_reference(text, self.values)
+            validation = _parser.parse(repr(reference_value))
+            if validation is None:
+                key = get_key_from_reference(text)
+                raise NotCompatibleTypes(f"The reference value of '{key}' is not compatible with '{type_name}'.")
+            return text
+        return with_pattern(REF_PATTERN)(parse_reference)
+
+    def get_aliases_with_reference_support(self):
+        return {
+            param_type: TypeBuilder.make_variant([parser_func, self.parse_reference_of(param_type, parser_func)])
+            for param_type, parser_func in alias_parameters_types.items()
+        }

data_sitter-0.1.0/data_sitter/rules/Parser/__init__.py

@@ -0,0 +1,8 @@
+from .RuleParser import RuleParser
+from .parser_utils import get_key_from_reference, get_value_from_reference
+
+__all__ = [
+    "RuleParser",
+    "get_key_from_reference",
+    "get_value_from_reference",
+]

data_sitter-0.1.0/data_sitter/rules/Parser/alias_parameters_parser.py

@@ -0,0 +1,78 @@
+from typing import Callable
+from parse import with_pattern, Parser
+
+from parse_type import TypeBuilder
+
+
+class NotCompatibleTypes(Exception):
+    pass
+
+
+@with_pattern(r"-?\d+")
+def parse_int(text):
+    return int(text)
+
+
+@with_pattern(r"-?\d*.\d+")
+def parse_float(text):
+    return float(text)
+
+
+@with_pattern(r"-?\d+.?\d*")
+def parse_number(text):
+    if "." in text:
+        return float(text)
+    return int(text)
+
+
+@with_pattern(r"|".join([r'"[^"]*"', "'[^']*'"]))
+def parse_string(text: str):
+    return text[1:-1]
+
+
+def parse_array_of(type_name: str, type_parser: Callable):
+    items_type = TypeBuilder.with_many0(type_parser, type_parser.pattern, listsep=",")
+    _parser = Parser(f"{{value:{type_name}}}", extra_types={type_name: items_type})
+
+    def parse_list(text: str):
+        text_without_brackets = text[1:-1]
+        validation = _parser.parse(text_without_brackets)
+        if validation is None:
+            raise NotCompatibleTypes(f"This shouldn't happens but items of the array '{type_name}' are not compatible?.")
+
+        return validation['value']
+
+    list_pattern = rf"\[{items_type.pattern}\]"
+    return with_pattern(list_pattern)(parse_list)
+
+
+alias_parameters_types = {
+    "Integer": parse_int,
+    "Integers": parse_array_of("Integer", parse_int),
+    "Float": parse_float,
+    "Floats": parse_array_of("Float", parse_float),
+    "Number": parse_number,
+    "Numbers": parse_array_of("Number", parse_number),
+    "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-0.1.0/data_sitter/rules/Parser/parser_utils.py

@@ -0,0 +1,27 @@
+import re
+
+
+REF_PATTERN = r'\$values\.([a-zA-Z0-9_]+)'
+VALUE_REF_PATTERN = re.compile(REF_PATTERN)
+
+
+class MalformedReference(Exception):
+    pass
+
+class ReferenceNotFound(Exception):
+    pass
+
+
+def get_key_from_reference(reference: str):
+    match = VALUE_REF_PATTERN.fullmatch(reference)
+    if match is None:
+        raise MalformedReference(f"Unrecognised Reference: {reference}")
+
+    return match.group(1)
+
+
+def get_value_from_reference(reference: str, values: dict):
+    key = get_key_from_reference(reference)
+    if key not in values:
+        raise ReferenceNotFound(f"Reference '{key}' not found in values.")
+    return values[key]

data_sitter-0.1.0/data_sitter/rules/Rule.py

@@ -0,0 +1,44 @@
+import string
+from inspect import signature
+from typing import Callable
+
+
+class NotAClassMethod(Exception):
+    pass
+
+
+class RuleFunctionParamsMismatch(Exception):
+    pass
+
+
+class Rule:
+    field_type: str
+    field_rule: str
+    rule_setter: Callable
+
+    def __init__(self, field_type: str, field_rule: str, rule_setter: Callable) -> None:
+        self.field_type = field_type
+        self.field_rule = field_rule
+        self.rule_setter = rule_setter
+        self.__validate_rule_function_params()
+
+    def __repr__(self):
+        return self.field_rule
+
+    @property
+    def rule_params(self) -> dict:
+        params = string.Formatter().parse(self.field_rule)
+        return {param: param_type for _, param, param_type, _ in params if param is not None}
+
+    def __get_rule_setter_params(self) -> set:
+        rule_setter_sign = signature(self.rule_setter)
+        return set(rule_setter_sign.parameters.keys())
+
+    def __validate_rule_function_params(self):
+        rule_setter_params = self.__get_rule_setter_params()
+        if "self" not in rule_setter_params:
+            raise NotAClassMethod()
+
+        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}")

data_sitter-0.1.0/data_sitter/rules/RuleRegistry.py

@@ -0,0 +1,65 @@
+from itertools import chain
+from collections import defaultdict
+from typing import TYPE_CHECKING, Dict, List, Type
+
+from .Rule import Rule
+from ..utils.logger_config import get_logger
+
+
+if TYPE_CHECKING:
+    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)
+
+            rule = Rule(field_type, field_rule, func)
+            cls.rules[field_type].append(rule)
+            logger.debug("Function '%s' Registered", func_name)
+            return func
+
+        return _register
+
+    @classmethod
+    def register_field(cls, field_class: Type["BaseField"]) -> Type["BaseField"]:
+        cls.type_map[field_class.__name__] = field_class
+        return field_class
+
+    @classmethod
+    def get_type(cls, field_type: str) -> Type["BaseField"]:
+        return cls.type_map.get(field_type)
+
+    @classmethod
+    def get_rules_for(cls, field_class: Type["BaseField"]):
+        if field_class.__name__ == "BaseField":
+            return cls.rules["BaseField"]
+        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
+
+    @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, [])
+            }
+            for field_name, field_class in cls.type_map.items()
+        ]
+
+
+def register_rule(rule: str):
+    return RuleRegistry.register_rule(rule)
+
+
+def register_field(field_class: type):
+    return RuleRegistry.register_field(field_class)

data_sitter-0.1.0/data_sitter/rules/__init__.py

@@ -0,0 +1,14 @@
+from .Rule import Rule
+from .Parser import RuleParser
+from .MatchedRule import MatchedRule
+from .RuleRegistry import RuleRegistry, register_rule, register_field
+
+
+__all__ = [
+    "Rule",
+    "MatchedRule",
+    "RuleParser",
+    "RuleRegistry",
+    "register_rule",
+    "register_field",
+]

data_sitter-0.1.0/data_sitter/utils/logger_config.py

@@ -0,0 +1,43 @@
+import logging
+import logging.config
+from os import environ
+
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
+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:
+    LOG_LEVEL = DEFAULT_LEVEL
+
+
+def configure_logging():
+    logging.config.dictConfig(
+        {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "standard": {
+                    "format": "[%(asctime)s] %(name)s [%(levelname)s] %(funcName)s - %(filename)s:%(lineno)d - %(message)s"
+                },
+            },
+            "handlers": {
+                "default": {
+                    "level": LOG_LEVEL,
+                    "formatter": "standard",
+                    "class": "logging.StreamHandler",
+                    "stream": "ext://sys.stdout",  # Use standard output
+                },
+            },
+            "loggers": {"": {"handlers": ["default"], "level": LOG_LEVEL, "propagate": True}},  # root logger
+        }
+    )
+
+configure_logging()
+
+def get_logger(name: str):
+    return logging.getLogger(name)

data_sitter-0.1.0/data_sitter.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.2
+Name: data-sitter
+Version: 0.1.0
+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: parse_type==0.6.4
+Requires-Dist: pydantic==2.10.6

data_sitter-0.1.0/data_sitter.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+README.md
+pyproject.toml
+setup.py
+data_sitter/Contract.py
+data_sitter/FieldResolver.py
+data_sitter/__init__.py
+data_sitter/cli.py
+data_sitter.egg-info/PKG-INFO
+data_sitter.egg-info/SOURCES.txt
+data_sitter.egg-info/dependency_links.txt
+data_sitter.egg-info/entry_points.txt
+data_sitter.egg-info/requires.txt
+data_sitter.egg-info/top_level.txt
+data_sitter/field_types/BaseField.py
+data_sitter/field_types/FloatField.py
+data_sitter/field_types/IntegerField.py
+data_sitter/field_types/NumericField.py
+data_sitter/field_types/StringField.py
+data_sitter/field_types/__init__.py
+data_sitter/rules/MatchedRule.py
+data_sitter/rules/Rule.py
+data_sitter/rules/RuleRegistry.py
+data_sitter/rules/__init__.py
+data_sitter/rules/Parser/RuleParser.py
+data_sitter/rules/Parser/__init__.py
+data_sitter/rules/Parser/alias_parameters_parser.py
+data_sitter/rules/Parser/parser_utils.py
+data_sitter/utils/__init__.py
+data_sitter/utils/logger_config.py

data_sitter-0.1.0/data_sitter.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

data_sitter-0.1.0/data_sitter.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+data-sitter = data_sitter.cli:main

data_sitter-0.1.0/data_sitter.egg-info/requires.txt

@@ -0,0 +1,3 @@
+python-dotenv==1.0.1
+parse_type==0.6.4
+pydantic==2.10.6

data_sitter-0.1.0/data_sitter.egg-info/top_level.txt

@@ -0,0 +1 @@
+data_sitter

data_sitter-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=76", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = 'data-sitter'
+version = "0.1.0"
+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'},
+]
+dependencies = [
+    # Keep this in sync with setup.py
+    "python-dotenv==1.0.1",
+    "parse_type==0.6.4",
+    "pydantic==2.10.6",
+]
+
+[project.scripts]
+data-sitter = "data_sitter.cli:main"

data_sitter-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

data_sitter-0.1.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+
+setup(
+    name='data-sitter',
+    version='0.1.0',
+    packages=find_packages(),
+    install_requires=[
+        # Keep this in sync with pyproject.toml
+        "python-dotenv==1.0.1",
+        "parse_type==0.6.4",
+        "pydantic==2.10.6",
+    ],
+    entry_points={
+        'console_scripts': [
+        'data-sitter=data_sitter.cli:main',
+        ],
+    },
+)