ripple-down-rules 0.1.67__py3-none-any.whl → 0.1.69__py3-none-any.whl

ripple_down_rules/datastructures/callable_expression.py

@@ -225,6 +225,8 @@ def parse_string_to_expression(expression_str: str) -> AST:
     :param expression_str: The string which will be parsed.
     :return: The parsed expression.
     """
+    if not expression_str.startswith('def'):
+        expression_str = encapsulate_user_input(expression_str, CallableExpression.encapsulating_function)
     mode = 'exec' if expression_str.startswith('def') else 'eval'
     tree = ast.parse(expression_str, mode=mode)
     logging.debug(f"AST parsed successfully: {ast.dump(tree)}")

ripple_down_rules/datastructures/case.py

@@ -11,7 +11,7 @@ from sqlalchemy.orm import DeclarativeBase as SQLTable, MappedColumn as SQLColum
 from typing_extensions import Any, Optional, Dict, Type, Set, Hashable, Union, List, TYPE_CHECKING
 
 from ..utils import make_set, row_to_dict, table_rows_as_str, get_value_type_from_type_hint, SubclassJSONSerializer, \
-    get_full_class_name, get_type_from_string, make_list, is_iterable, serialize_dataclass
+    get_full_class_name, get_type_from_string, make_list, is_iterable, serialize_dataclass, dataclass_to_dict
 
 if TYPE_CHECKING:
     from ripple_down_rules.rules import Rule
@@ -99,8 +99,7 @@ class Case(UserDict, SubclassJSONSerializer):
         obj_type = get_type_from_string(data.pop("_obj_type"))
         name = data.pop("_name")
         for k, v in data.items():
-            if isinstance(v, dict) and "_type" in v:
-                data[k] = SubclassJSONSerializer.from_json(v)
+            data[k] = SubclassJSONSerializer.from_json(v)
         return cls(_obj_type=obj_type, _id=id_, _name=name, **data)
 
 
@@ -219,7 +218,7 @@ def create_case(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
     obj_name = obj_name or obj.__class__.__name__
     if isinstance(obj, DataFrame):
         return create_cases_from_dataframe(obj, obj_name)
-    if isinstance(obj, Case):
+    if isinstance(obj, Case) or (is_dataclass(obj) and not isinstance(obj, SQLTable)):
         return obj
     if ((recursion_idx > max_recursion_idx) or (obj.__class__.__module__ == "builtins")
             or (obj.__class__ in [MetaData, registry])):
@@ -318,6 +317,10 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] =
         case_dict = row_to_dict(case)
         if last_evaluated_rule and last_evaluated_rule.fired:
             corner_row_dict = row_to_dict(last_evaluated_rule.corner_case)
+    elif is_dataclass(case):
+        case_dict = dataclass_to_dict(case)
+        if last_evaluated_rule and last_evaluated_rule.fired:
+            corner_row_dict = dataclass_to_dict(last_evaluated_rule.corner_case)
     else:
         case_dict = case
         if last_evaluated_rule and last_evaluated_rule.fired:

ripple_down_rules/rdr.py

@@ -211,17 +211,17 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         func_def = f"def classify(case: {self.case_type.__name__}) -> {self.conclusion_type_hint}:\n"
         file_name = file_path + f"/{self.generated_python_file_name}.py"
         defs_file_name = file_path + f"/{self.generated_python_defs_file_name}.py"
-        imports = self._get_imports()
+        imports, defs_imports = self._get_imports()
         # clear the files first
         with open(defs_file_name, "w") as f:
-            f.write(imports + "\n\n")
+            f.write(defs_imports + "\n\n")
         with open(file_name, "w") as f:
             imports += f"from .{self.generated_python_defs_file_name} import *\n"
             imports += f"from ripple_down_rules.rdr import {self.__class__.__name__}\n"
             f.write(imports + "\n\n")
-            f.write(f"conclusion_type = ({', '.join([ct.__name__ for ct in self.conclusion_type])},)\n\n")
-            f.write(f"type_ = {self.__class__.__name__}\n\n")
-            f.write(func_def)
+            f.write(f"conclusion_type = ({', '.join([ct.__name__ for ct in self.conclusion_type])},)\n")
+            f.write(f"type_ = {self.__class__.__name__}\n")
+            f.write(f"\n\n{func_def}")
             f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
                     f"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
             self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4, defs_file=defs_file_name)
@@ -234,17 +234,11 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         pass
 
-    def _get_imports(self) -> str:
+    def _get_imports(self) -> Tuple[str, str]:
         """
         :return: The imports for the generated python file of the RDR as a string.
         """
-        imports = ""
-        if self.case_type.__module__ != "builtins":
-            imports += f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
-        for conclusion_type in self.conclusion_type:
-            if conclusion_type.__module__ != "builtins":
-                imports += f"from {conclusion_type.__module__} import {conclusion_type.__name__}\n"
-        imports += "from ripple_down_rules.datastructures.case import Case, create_case\n"
+        defs_imports = ""
         for rule in [self.start_rule] + list(self.start_rule.descendants):
             if not rule.conditions:
                 continue
@@ -255,10 +249,21 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
                     if not hasattr(v, "__module__") or not hasattr(v, "__name__"):
                         continue
                     new_imports = f"from {v.__module__} import {v.__name__}\n"
-                    if new_imports in imports:
+                    if new_imports in defs_imports:
                         continue
-                    imports += new_imports
-        return imports
+                    defs_imports += new_imports
+        imports = ""
+        if self.case_type.__module__ != "builtins":
+            new_import = f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
+            if new_import not in defs_imports:
+                imports += new_import
+        for conclusion_type in self.conclusion_type:
+            if conclusion_type.__module__ != "builtins":
+                new_import = f"from {conclusion_type.__module__} import {conclusion_type.__name__}\n"
+                if new_import not in defs_imports:
+                    imports += new_import
+        imports += "from ripple_down_rules.datastructures.case import Case, create_case\n"
+        return imports, defs_imports
 
     def get_rdr_classifier_from_python_file(self, package_name: str) -> Callable[[Any], Any]:
         """
@@ -293,7 +298,11 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         :return: The default generated python file name.
         """
-        return f"{self.start_rule.corner_case._name.lower()}_{self.attribute_name}_{self.acronym.lower()}"
+        if isinstance(self.start_rule.corner_case, Case):
+            name = self.start_rule.corner_case._name
+        else:
+            name = self.start_rule.corner_case.__class__.__name__
+        return f"{name.lower()}_{self.attribute_name}_{self.acronym.lower()}"
 
     @property
     def generated_python_defs_file_name(self) -> str:
@@ -539,13 +548,21 @@ class MultiClassRDR(RDRWithCodeWriter):
 
     @property
     def conclusion_type_hint(self) -> str:
-        return f"Set[Union[{', '.join([ct.__name__ for ct in self.conclusion_type if ct not in [list, set]])}]]"
+        conclusion_types = [ct.__name__ for ct in self.conclusion_type if ct not in [list, set]]
+        if len(conclusion_types) == 1:
+            return f"Set[{conclusion_types[0]}]"
+        else:
+            return f"Set[Union[{', '.join(conclusion_types)}]]"
 
-    def _get_imports(self) -> str:
-        imports = super()._get_imports()
-        imports += "from typing_extensions import Set, Union\n"
+    def _get_imports(self) -> Tuple[str, str]:
+        imports, defs_imports = super()._get_imports()
+        conclusion_types = [ct for ct in self.conclusion_type if ct not in [list, set]]
+        if len(conclusion_types) == 1:
+            imports += f"from typing_extensions import Set\n"
+        else:
+            imports += "from typing_extensions import Set, Union\n"
         imports += "from ripple_down_rules.utils import make_set\n"
-        return imports
+        return imports, defs_imports
 
     def update_start_rule(self, case_query: CaseQuery, expert: Expert):
         """
@@ -867,7 +884,11 @@ class GeneralRDR(RippleDownRules):
         """
         :return: The default generated python file name.
         """
-        return f"{self.start_rule.corner_case._name.lower()}_rdr"
+        if isinstance(self.start_rule.corner_case, Case):
+            name = self.start_rule.corner_case._name
+        else:
+            name = self.start_rule.corner_case.__class__.__name__
+        return f"{name}_rdr".lower()
 
     @property
     def conclusion_type_hint(self) -> str:
@@ -882,17 +903,12 @@ class GeneralRDR(RippleDownRules):
         """
         imports = ""
         # add type hints
-        imports += f"from typing_extensions import Dict, Any, Union, Set\n"
+        imports += f"from typing_extensions import Dict, Any\n"
         # import rdr type
         imports += f"from ripple_down_rules.rdr import GeneralRDR\n"
         # add case type
         imports += f"from ripple_down_rules.datastructures.case import Case, create_case\n"
         imports += f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
-        # add conclusion type imports
-        for rdr in self.start_rules_dict.values():
-            for conclusion_type in rdr.conclusion_type:
-                if conclusion_type.__module__ != "builtins":
-                    imports += f"from {conclusion_type.__module__} import {conclusion_type.__name__}\n"
         # add rdr python generated functions.
         for rdr_key, rdr in self.start_rules_dict.items():
             imports += (f"from {file_path.strip('./')}"

ripple_down_rules/rules.py

@@ -93,7 +93,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         conclusion_func, conclusion_func_call = self._conclusion_source_code(conclusion, parent_indent=parent_indent)
         if conclusion_func is not None:
             with open(defs_file, 'a') as f:
-                f.write(conclusion_func + "\n\n")
+                f.write(conclusion_func.strip() + "\n\n\n")
         return conclusion_func_call
 
     @abstractmethod
@@ -120,7 +120,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             conditions_lines[0] = re.sub(r"def (\w+)", new_function_name, conditions_lines[0])
             def_code = "\n".join(conditions_lines)
             with open(defs_file, 'a') as f:
-                f.write(def_code + "\n\n")
+                f.write(def_code.strip() + "\n\n\n")
             return f"\n{parent_indent}{if_clause} {new_function_name.replace('def ', '')}(case):\n"
 
     @abstractmethod
@@ -131,7 +131,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         json_serialization = {"conditions": self.conditions.to_json(),
                               "conclusion": conclusion_to_json(self.conclusion),
                               "parent": self.parent.json_serialization if self.parent else None,
-                              "corner_case": self.corner_case.to_json() if self.corner_case else None,
+                              "corner_case": SubclassJSONSerializer.to_json_static(self.corner_case),
                               "conclusion_name": self.conclusion_name,
                               "weight": self.weight}
         return json_serialization

ripple_down_rules/utils.py

@@ -7,6 +7,7 @@ import json
 import logging
 import os
 import re
+import uuid
 from collections import UserDict
 from copy import deepcopy
 from dataclasses import is_dataclass, fields
@@ -322,7 +323,7 @@ def extract_dependencies(code_lines):
     return required_lines
 
 
-def serialize_dataclass(obj: Any) -> Union[Dict, Any]:
+def serialize_dataclass(obj: Any, seen=None) -> Any:
     """
     Recursively serialize a dataclass to a dictionary. If the dataclass contains any nested dataclasses, they will be
     serialized as well. If the object is not a dataclass, it will be returned as is.
@@ -330,24 +331,44 @@ def serialize_dataclass(obj: Any) -> Union[Dict, Any]:
     :param obj: The dataclass to serialize.
     :return: The serialized dataclass as a dictionary or the object itself if it is not a dataclass.
     """
-
-    def recursive_convert(obj):
-        if is_dataclass(obj):
-            return {
-                "__dataclass__": f"{obj.__class__.__module__}.{obj.__class__.__qualname__}",
-                "fields": {f.name: recursive_convert(getattr(obj, f.name)) for f in fields(obj)}
-            }
-        elif isinstance(obj, list):
-            return [recursive_convert(item) for item in obj]
-        elif isinstance(obj, dict):
-            return {k: recursive_convert(v) for k, v in obj.items()}
-        else:
+    if seen is None:
+        seen = {}
+
+    obj_id = id(obj)
+    if obj_id in seen:
+        return {'$ref': seen[obj_id]}
+
+    if is_dataclass(obj):
+        uid = str(uuid.uuid4())
+        seen[obj_id] = uid
+        result = {
+            '$id': uid,
+            "__dataclass__": f"{obj.__class__.__module__}.{obj.__class__.__qualname__}",
+            'fields': {}
+        }
+        for f in fields(obj):
+            value = getattr(obj, f.name)
+            result['fields'][f.name] = serialize_dataclass(value, seen)
+        return result
+    elif isinstance(obj, list):
+        return [serialize_dataclass(v, seen) for v in obj]
+    elif isinstance(obj, dict):
+        return {k: serialize_dataclass(v, seen) for k, v in obj.items()}
+    else:
+        try:
+            json.dumps(obj)  # Check if the object is JSON serializable
             return obj
+        except TypeError:
+            return None
 
-    return recursive_convert(obj)
 
+def deserialize_dataclass(data: Any, refs: Optional[Dict[str, Any]] = None) -> Any:
+    refs = {} if refs is None else refs
+    preloaded = preload_serialized_objects(data, refs)
+    return resolve_refs(preloaded, refs)
 
-def deserialize_dataclass(data: dict) -> Any:
+
+def preload_serialized_objects(data: Any, refs: Dict[str, Any] = None) -> Any:
     """
     Recursively deserialize a dataclass from a dictionary, if the dictionary contains a key "__dataclass__" (Most likely
     created by the serialize_dataclass function), it will be treated as a dataclass and deserialized accordingly,
@@ -356,25 +377,81 @@ def deserialize_dataclass(data: dict) -> Any:
     :param data: The dictionary to deserialize.
     :return: The deserialized dataclass.
     """
+    if refs is None:
+        refs = {}
+
+    if isinstance(data, dict):
+
+        if '$ref' in data:
+            ref_id = data['$ref']
+            if ref_id not in refs:
+                return {'$ref': data['$ref']}
+            return refs[ref_id]
+
+        elif '$id' in data and '__dataclass__' in data and 'fields' in data:
+            cls_path = data['__dataclass__']
+            module_name, class_name = cls_path.rsplit('.', 1)
+            cls = getattr(importlib.import_module(module_name), class_name)
+
+            dummy_instance = cls.__new__(cls)  # Don't call __init__ yet
+            refs[data['$id']] = dummy_instance
+
+            for f in fields(cls):
+                raw_value = data['fields'].get(f.name)
+                value = preload_serialized_objects(raw_value, refs)
+                setattr(dummy_instance, f.name, value)
+
+            return dummy_instance
 
-    def recursive_load(obj):
-        if isinstance(obj, dict) and "__dataclass__" in obj:
-            module_name, class_name = obj["__dataclass__"].rsplit(".", 1)
-            module = importlib.import_module(module_name)
-            cls: Type = getattr(module, class_name)
-            field_values = {
-                k: recursive_load(v)
-                for k, v in obj["fields"].items()
-            }
-            return cls(**field_values)
-        elif isinstance(obj, list):
-            return [recursive_load(item) for item in obj]
-        elif isinstance(obj, dict):
-            return {k: recursive_load(v) for k, v in obj.items()}
         else:
-            return obj
+            return {k: preload_serialized_objects(v, refs) for k, v in data.items()}
+
+    elif isinstance(data, list):
+        return [preload_serialized_objects(item, refs) for item in data]
+    elif isinstance(data, dict):
+        return {k: preload_serialized_objects(v, refs) for k, v in data.items()}
+
+    return data  # Primitive
 
-    return recursive_load(data)
+
+def resolve_refs(obj, refs, seen=None):
+    if seen is None:
+        seen = {}
+
+    obj_id = id(obj)
+    if obj_id in seen:
+        return seen[obj_id]
+
+    # Resolve if dict with $ref
+    if isinstance(obj, dict) and '$ref' in obj:
+        ref_id = obj['$ref']
+        if ref_id not in refs:
+            raise KeyError(f"$ref to unknown ID: {ref_id}")
+        return refs[ref_id]
+
+    elif is_dataclass(obj):
+        seen[obj_id] = obj  # Mark before diving deeper
+        for f in fields(obj):
+            val = getattr(obj, f.name)
+            resolved = resolve_refs(val, refs, seen)
+            setattr(obj, f.name, resolved)
+        return obj
+
+    elif isinstance(obj, list):
+        resolved_list = []
+        seen[obj_id] = resolved_list
+        for item in obj:
+            resolved_list.append(resolve_refs(item, refs, seen))
+        return resolved_list
+
+    elif isinstance(obj, dict):
+        resolved_dict = {}
+        seen[obj_id] = resolved_dict
+        for k, v in obj.items():
+            resolved_dict[k] = resolve_refs(v, refs, seen)
+        return resolved_dict
+
+    return obj  # Primitive
 
 
 def typing_to_python_type(typing_hint: Type) -> Type:
@@ -547,6 +624,7 @@ class SubclassJSONSerializer:
     Classes that inherit from this class can be serialized and deserialized automatically by calling this classes
     'from_json' method.
     """
+    data_class_refs = {}
 
     def to_json_file(self, filename: str):
         """
@@ -560,8 +638,14 @@ class SubclassJSONSerializer:
             json.dump(data, f, indent=4)
         return data
 
+    @staticmethod
+    def to_json_static(obj) -> Dict[str, Any]:
+        if is_dataclass(obj):
+            return serialize_dataclass(obj)
+        return {"_type": get_full_class_name(obj.__class__), **obj._to_json()}
+
     def to_json(self) -> Dict[str, Any]:
-        return {"_type": get_full_class_name(self.__class__), **self._to_json()}
+        return self.to_json_static(self)
 
     def _to_json(self) -> Dict[str, Any]:
         """
@@ -582,7 +666,7 @@ class SubclassJSONSerializer:
         raise NotImplementedError()
 
     @classmethod
-    def from_json_file(cls, filename: str):
+    def from_json_file(cls, filename: str) -> Any:
         """
         Create an instance of the subclass from the data in the given json file.
 
@@ -592,7 +676,9 @@ class SubclassJSONSerializer:
             filename += ".json"
         with open(filename, "r") as f:
             scrdr_json = json.load(f)
-        return cls.from_json(scrdr_json)
+        deserialized_obj = cls.from_json(scrdr_json)
+        cls.data_class_refs.clear()
+        return deserialized_obj
 
     @classmethod
     def from_json(cls, data: Dict[str, Any]) -> Self:
@@ -604,11 +690,17 @@ class SubclassJSONSerializer:
         """
         if data is None:
             return None
-        if not isinstance(data, dict) or ('_type' not in data):
+        if isinstance(data, list):
+            # if the data is a list, deserialize it
+            return [cls.from_json(d) for d in data]
+        elif isinstance(data, dict):
+            if '__dataclass__' in data:
+                # if the data is a dataclass, deserialize it
+                return deserialize_dataclass(data, cls.data_class_refs)
+            elif '_type' not in data:
+                return {k: cls.from_json(v) for k, v in data.items()}
+        elif not isinstance(data, dict):
             return data
-        if '__dataclass__' in data:
-            # if the data is a dataclass, deserialize it
-            return deserialize_dataclass(data)
 
         # check if type module is builtins
         data_type = get_type_from_string(data["_type"])
@@ -757,6 +849,19 @@ def row_to_dict(obj):
     }
 
 
+def dataclass_to_dict(obj):
+    """
+    Convert a dataclass to a dictionary.
+
+    :param obj: The dataclass to convert.
+    :return: The dictionary representation of the dataclass.
+    """
+    if is_dataclass(obj):
+        return {f.name: getattr(obj, f.name) for f in fields(obj) if not f.name.startswith("_")}
+    else:
+        raise ValueError(f"Object {obj} is not a dataclass.")
+
+
 def get_attribute_name(obj: Any, attribute: Optional[Any] = None, attribute_type: Optional[Type] = None,
                        possible_value: Optional[Any] = None) -> Optional[str]:
     """

{ripple_down_rules-0.1.67.dist-info → ripple_down_rules-0.1.69.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.67
+Version: 0.1.69
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 License:                     GNU GENERAL PUBLIC LICENSE

{ripple_down_rules-0.1.67.dist-info → ripple_down_rules-0.1.69.dist-info}/RECORD

@@ -4,17 +4,17 @@ ripple_down_rules/experts.py,sha256=JGVvSNiWhm4FpRpg76f98tl8Ii_C7x_aWD9FxD-JDLQ,
 ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
 ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
 ripple_down_rules/prompt.py,sha256=gdLV2qhq-1kbmlJhVmkCwGGFhIeDxV0p5u2hwrbGUpk,6370
-ripple_down_rules/rdr.py,sha256=LNXkiS-Dc7inGPKvTxZDarYPFsw9mSEWB6YDHl58g2A,41536
+ripple_down_rules/rdr.py,sha256=E8YXSU_VMd3e_LJItjzbBjr0g1KXhhU_HL4FMAgdczc,42203
 ripple_down_rules/rdr_decorators.py,sha256=8SclpceI3EtrsbuukWJu8HGLh7Q1ZCgYGLX-RPlG-w0,2018
-ripple_down_rules/rules.py,sha256=SxP94X7I0XImG5zuEWLDfmINihwBKL-h_j1v2EMcVtg,16557
-ripple_down_rules/utils.py,sha256=MABj84x3v6gF5j2HscoQXnAZnupAGio3WjtsrTtVlRo,36473
+ripple_down_rules/rules.py,sha256=WfMWzgfI_5Tqv8a2k7jkpGdvwu-zYCG36EmpCl7GiEQ,16576
+ripple_down_rules/utils.py,sha256=INGRVIUH-SgssUW2T9gUMRf-XyJ3rxY_kuJUxfbsyOg,39683
 ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
-ripple_down_rules/datastructures/callable_expression.py,sha256=4AxguiVeSTxzYti5AyOWHdqWzS6KdSPWqf0unR9ZuhA,9636
-ripple_down_rules/datastructures/case.py,sha256=uM5YkJOfYfARrZZ3oAxKMWE5QBSnvHLLZa9Atoxb7eY,13800
+ripple_down_rules/datastructures/callable_expression.py,sha256=JLd8ZdIvAGX3mm-tID0buZIlbMF6hW2Z_jn5KA7X_ws,9788
+ripple_down_rules/datastructures/case.py,sha256=nJDKOjyhGLx4gt0sHxJNxBLdy9X2SLcDn89_SmKzwoc,14035
 ripple_down_rules/datastructures/dataclasses.py,sha256=TAOAeEvh0BeTis3rEHu8rpCeqNNhU0vK3to0JaBwTio,5961
 ripple_down_rules/datastructures/enums.py,sha256=RdyPUp9Ls1QuLmkcMMkBbCWrmXIZI4xWuM-cLPYZhR0,4666
-ripple_down_rules-0.1.67.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.1.67.dist-info/METADATA,sha256=qlVXkthupuQp5K2PIWp_aFfGVP28rGWW3UXDx2enFBc,42576
-ripple_down_rules-0.1.67.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-ripple_down_rules-0.1.67.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.1.67.dist-info/RECORD,,
+ripple_down_rules-0.1.69.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.1.69.dist-info/METADATA,sha256=hjuztFZVWpCOPfWULTsRdVCrfeMo8nc2XI4DdW4GJ9g,42576
+ripple_down_rules-0.1.69.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+ripple_down_rules-0.1.69.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.1.69.dist-info/RECORD,,