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

data_sitter/Contract.py

@@ -1,8 +1,11 @@
+import json
+import yaml
 from typing import Any, Dict, List, NamedTuple
 from functools import cached_property
 
 from pydantic import BaseModel
 
+from .Validation import Validation
 from .field_types import BaseField
 from .FieldResolver import FieldResolver
 from .rules import MatchedRule, RuleRegistry, RuleParser
@@ -51,6 +54,14 @@ class Contract:
             values=contract_dict.get("values", {}),
         )
 
+    @classmethod
+    def from_json(cls, contract_json: str):
+        return cls.from_dict(json.loads(contract_json))
+
+    @classmethod
+    def from_yaml(cls, contract_yaml: str):
+        return cls.from_dict(yaml.load(contract_yaml, yaml.Loader))
+
     @cached_property
     def field_validators(self) -> Dict[str, BaseField]:
         field_validators = {}
@@ -68,10 +79,13 @@ class Contract:
         return rules
 
     def model_validate(self, item: dict):
-        pydantic_model = self.get_pydantic_model()
-        return pydantic_model.model_validate(item).model_dump()
+        return self.pydantic_model.model_validate(item).model_dump()
+
+    def validate(self, item: dict) -> Validation:
+        return Validation.validate(self.pydantic_model, item)
 
-    def get_pydantic_model(self) -> BaseModel:
+    @cached_property
+    def pydantic_model(self) -> BaseModel:
         return type(self.name, (BaseModel,), {
             "__annotations__": {
                 field_name: field_validator.get_annotation()
@@ -79,7 +93,28 @@ class Contract:
             }
         })
 
-    def get_front_end_contract(self):
+    @cached_property
+    def contract(self) -> dict:
+        return {
+            "name": self.name,
+            "fields": [
+                {
+                    "field_name": field_name,
+                    "field_type": field_validator.__class__.__name__,
+                    "field_rules": [rule.parsed_rule for rule in self.rules.get(field_name, [])]
+                }
+                for field_name, field_validator in self.field_validators.items()
+            ],
+            "values": self.rule_parser.values
+        }
+
+    def get_json_contract(self, indent: int=2) -> str:
+        return json.dumps(self.contract, indent=indent)
+
+    def get_yaml_contract(self, indent: int=2) -> str:
+        return yaml.dump(self.contract, Dumper=yaml.Dumper, indent=indent, sort_keys=False)
+
+    def get_front_end_contract(self) -> dict:
         return {
             "name": self.name,
             "fields": [

data_sitter/FieldResolver.py

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

data_sitter/Validation.py

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

data_sitter/cli.py

@@ -23,7 +23,7 @@ def main():
     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()
+    pydantic_contract = contract.pydantic_model
 
     if file_path.suffix == '.csv':
         with open(file_path, encoding=encoding) as f:

data_sitter/field_types/BaseField.py

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

data_sitter/field_types/FloatField.py

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

data_sitter/field_types/NumericField.py

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

data_sitter/field_types/StringField.py

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

data_sitter/rules/Rule.py

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

data_sitter/rules/RuleRegistry.py

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

{data_sitter-0.1.2.dist-info → data_sitter-0.1.4.dist-info}/METADATA

@@ -1,8 +1,9 @@
 Metadata-Version: 2.2
 Name: data-sitter
-Version: 0.1.2
+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

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

data_sitter-0.1.2.dist-info/RECORD

@@ -1,25 +0,0 @@
-data_sitter/Contract.py,sha256=87GcIltT0ofhZNZg_de8DP4rTj9Ab2pvGr-HSVACrfs,3375
-data_sitter/FieldResolver.py,sha256=aSavmk3V8QCphLRL6i3T_V2DIsWfEKBdcCnZC71hrx0,1895
-data_sitter/__init__.py,sha256=qbE-wU8ELMFwOMG4UTK0lmzn5XF2MK3rc22E8ROgypo,113
-data_sitter/cli.py,sha256=J_FzO8qnF5AVS4PH2AY5ljs4IpCrIg2l2z6PpFsjjWk,1672
-data_sitter/field_types/BaseField.py,sha256=_Pg6a7gdmQFwb4f7LDyOxElX8j0NnTYZGOJJr_jddt8,1797
-data_sitter/field_types/FloatField.py,sha256=pWU449uUFzlpnIpZI-2WxN1YKv7PxIiYe_c7W91VqCc,147
-data_sitter/field_types/IntegerField.py,sha256=o__5z3bg6wsx7FIfJbBYZW5b760-WSZw_05J-OSKXR0,147
-data_sitter/field_types/NumericField.py,sha256=ncPSrUOOgU5MPcA7in_lR6Luqb1xOo8m7UL6TW1qqGw,2665
-data_sitter/field_types/StringField.py,sha256=XVN_0SE7bVlJijEiVIe_Ce22olY-DI0lmmZq3LU7TVE,3444
-data_sitter/field_types/__init__.py,sha256=GdssttQCJksGcZn7oPM53vOsqOL6R5xRiRJDEtr38Ww,293
-data_sitter/rules/MatchedRule.py,sha256=uHXuo7Np-Bq7IOHaHMYFmYFPRT8aYDEKCdFKcvWf4DM,1946
-data_sitter/rules/Rule.py,sha256=UzZku6qo6GEUmDT86KS1Ee-2S9f_TTYlHC_O87V-984,1327
-data_sitter/rules/RuleRegistry.py,sha256=YwBTsGY8S0ZDuwHuyQwcFgUWYORXK0Q44mV8v2oFVKc,2052
-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.2.dist-info/METADATA,sha256=bh7X-lbFECJk7uV1oT5miVBOVfypkYAERAS6wbAZ7r8,324
-data_sitter-0.1.2.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-data_sitter-0.1.2.dist-info/entry_points.txt,sha256=1I7xxqFZvA78wmDx7NGavttAb8JFWM3Wxgehftx_5C4,53
-data_sitter-0.1.2.dist-info/top_level.txt,sha256=Q7N21PYeqIdRbDvZQCJXhbbv0PFIf876gu1_DpInH_E,12
-data_sitter-0.1.2.dist-info/RECORD,,