ripple-down-rules 0.2.3__py3-none-any.whl → 0.3.0__py3-none-any.whl

ripple_down_rules/rdr_decorators.py

@@ -5,51 +5,135 @@ of the RDRs.
 """
 import os.path
 from functools import wraps
-from typing import Callable, Optional, Type
+from typing_extensions import Callable, Optional, Type, Tuple, Dict, Any, Self, get_type_hints, List, Union
 
-from sqlalchemy.orm import Session
-from typing_extensions import Any
-
-from ripple_down_rules.datastructures import Case, Category, create_case, CaseQuery
+from ripple_down_rules.datastructures.case import create_case
+from ripple_down_rules.datastructures.dataclasses import CaseQuery
+from ripple_down_rules.datastructures.enums import Category
 from ripple_down_rules.experts import Expert, Human
+from ripple_down_rules.rdr import GeneralRDR, RippleDownRules
+from ripple_down_rules.utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
+    get_method_class_if_exists
 
-from ripple_down_rules.rdr import SingleClassRDR, MultiClassRDR, GeneralRDR
-from ripple_down_rules.utils import get_method_args_as_dict, get_method_name, get_method_class_name_if_exists, \
-    get_method_file_name, get_func_rdr_model_path
-
-
-def single_class_rdr(
-    model_dir: str,
-    fit: bool = True,
-    expert: Optional[Expert] = None,
-    session: Optional[Session] = None,
-) -> Callable:
-    """
-    Decorator to use a SingleClassRDR as a classifier.
-    """
-    expert = expert if expert else Human(session=session)
-
-    def decorator(func: Callable) -> Callable:
-        scrdr_model_path = get_func_rdr_model_path(func, model_dir)
-        if os.path.exists(scrdr_model_path):
-            scrdr = SingleClassRDR.load(scrdr_model_path)
-            scrdr.session = session
-        else:
-            scrdr = SingleClassRDR(session=session)
+
+class RDRDecorator:
+    rdr: GeneralRDR
+
+    def __init__(self, models_dir: str,
+                 output_type: Tuple[Type],
+                 mutual_exclusive: bool,
+                 python_dir: Optional[str] = None,
+                 output_name: str = "output_",
+                 fit: bool = True,
+                 expert: Optional[Expert] = None):
+        """
+        :param models_dir: The directory to save/load the RDR models.
+        :param output_type: The type of the output. This is used to create the RDR model.
+        :param mutual_exclusive: If True, the output types are mutually exclusive.
+        :param python_dir: The directory to save the RDR model as a python file.
+         If None, the RDR model will not be saved as a python file.
+        :param output_name: The name of the output. This is used to create the RDR model.
+        :param fit: If True, the function will be in fit mode. This means that the RDR will prompt the user for the
+            correct output if the function's output is not in the RDR model. If False, the function will be in
+            classification mode. This means that the RDR will classify the function's output based on the RDR model.
+        :param expert: The expert that will be used to prompt the user for the correct output. If None, a Human
+            expert will be used.
+        :return: A decorator to use a GeneralRDR as a classifier that monitors and modifies the function's output.
+        """
+        self.rdr_models_dir = models_dir
+        self.output_type = output_type
+        self.parsed_output_type: List[Type] = []
+        self.mutual_exclusive = mutual_exclusive
+        self.rdr_python_path: Optional[str] = python_dir
+        self.output_name = output_name
+        self.fit: bool = fit
+        self.expert = expert if expert else Human()
+        self.rdr_model_path: Optional[str] = None
+        self.load()
+
+    def decorator(self, func: Callable) -> Callable:
 
         @wraps(func)
-        def wrapper(*args, **kwargs) -> Category:
+        def wrapper(*args, **kwargs) -> Optional[Any]:
+            if len(self.parsed_output_type) == 0:
+                self.parse_output_type(func, *args)
+            if self.rdr_model_path is None:
+                self.initialize_rdr_model_path_and_load(func)
             case_dict = get_method_args_as_dict(func, *args, **kwargs)
             func_output = func(*args, **kwargs)
-            if func_output is not None:
-                case_dict.update({"_output": func_output})
-            case = create_case(case_dict, recursion_idx=3)
-            if fit:
-                output = scrdr.fit_case(CaseQuery(case), expert=expert)
-                scrdr.save(scrdr_model_path)
-                return output
+            case_dict.update({self.output_name: func_output})
+            case = create_case(case_dict, obj_name=get_func_rdr_model_name(func), max_recursion_idx=3)
+            if self.fit:
+                scope = func.__globals__
+                scope.update(case_dict)
+                func_args_type_hints = get_type_hints(func)
+                func_args_type_hints.update({self.output_name: Union[tuple(self.parsed_output_type)]})
+                case_query = CaseQuery(case, self.output_name, Union[tuple(self.parsed_output_type)],
+                                       self.mutual_exclusive,
+                                       scope=scope, is_function=True, function_args_type_hints=func_args_type_hints)
+                output = self.rdr.fit_case(case_query, expert=self.expert)
+                return output[self.output_name]
             else:
-                return scrdr.classify(case)
+                return self.rdr.classify(case)[self.output_name]
+
         return wrapper
 
-    return decorator
+    def initialize_rdr_model_path_and_load(self, func: Callable) -> None:
+        model_file_name = get_func_rdr_model_name(func, include_file_name=True)
+        model_file_name = (''.join(['_' + c.lower() if c.isupper() else c for c in model_file_name]).lstrip('_')
+                           .replace('__', '_') + ".json")
+        self.rdr_model_path = os.path.join(self.rdr_models_dir, model_file_name)
+        self.load()
+
+    def parse_output_type(self, func: Callable, *args) -> None:
+        for ot in make_set(self.output_type):
+            if ot is Self:
+                func_class = get_method_class_if_exists(func, *args)
+                if func_class is not None:
+                    self.parsed_output_type.append(func_class)
+                else:
+                    raise ValueError(f"The function {func} is not a method of a class,"
+                                     f" and the output type is {Self}.")
+            else:
+                self.parsed_output_type.append(ot)
+
+    def save(self):
+        """
+        Save the RDR model to the specified directory.
+        """
+        self.rdr.save(self.rdr_model_path)
+
+        if self.rdr_python_path is not None:
+            if not os.path.exists(self.rdr_python_path):
+                os.makedirs(self.rdr_python_path)
+            if not os.path.exists(os.path.join(self.rdr_python_path, "__init__.py")):
+                # add __init__.py file to the directory
+                with open(os.path.join(self.rdr_python_path, "__init__.py"), "w") as f:
+                    f.write("# This is an empty __init__.py file to make the directory a package.")
+            # write the RDR model to a python file
+            self.rdr.write_to_python_file(self.rdr_python_path)
+
+    def load(self):
+        """
+        Load the RDR model from the specified directory.
+        """
+        if self.rdr_model_path is not None and os.path.exists(self.rdr_model_path):
+            self.rdr = GeneralRDR.load(self.rdr_model_path)
+        else:
+            self.rdr = GeneralRDR()
+
+    def write_to_python_file(self, package_dir: str, file_name_postfix: str = ""):
+        """
+        Write the RDR model to a python file.
+
+        :param package_dir: The path to the directory to write the python file.
+        """
+        self.rdr.write_to_python_file(package_dir, postfix=file_name_postfix)
+
+    def update_from_python_file(self, package_dir: str):
+        """
+        Update the RDR model from a python file.
+
+        :param package_dir: The directory of the package that contains the generated python file.
+        """
+        self.rdr.update_from_python_file(package_dir)

ripple_down_rules/utils.py

@@ -2,14 +2,16 @@ from __future__ import annotations
 
 import ast
 import builtins
+import copyreg
 import importlib
 import json
 import logging
 import os
 import re
+import threading
 import uuid
 from collections import UserDict
-from copy import deepcopy
+from copy import deepcopy, copy
 from dataclasses import is_dataclass, fields
 from enum import Enum
 from types import NoneType
@@ -26,14 +28,28 @@ from tabulate import tabulate
 from typing_extensions import Callable, Set, Any, Type, Dict, TYPE_CHECKING, get_type_hints, \
     get_origin, get_args, Tuple, Optional, List, Union, Self
 
+
 if TYPE_CHECKING:
     from .datastructures.case import Case
     from .datastructures.dataclasses import CaseQuery
-    from .rules import Rule
 
 import ast
 
-matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
+
+def str_to_snake_case(snake_str: str) -> str:
+    """
+    Convert a string to snake case.
+
+    :param snake_str: The string to convert.
+    :return: The converted string.
+    """
+    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', snake_str)
+    s1 = re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
+    # remove redundant underscores
+    s1 = re.sub(r'_{2,}', '_', s1)
+    # remove leading and trailing underscores
+    s1 = re.sub(r'^_|_$', '', s1)
+    return s1
 
 
 def are_results_subclass_of_types(result_types: List[Any], types_: List[Type]) -> bool:
@@ -613,13 +629,76 @@ def get_func_rdr_model_path(func: Callable, model_dir: str) -> str:
     :param model_dir: The directory to save the model to.
     :return: The path to the model file.
     """
+    return os.path.join(model_dir, f"{get_func_rdr_model_name(func)}.json")
+
+
+def get_func_rdr_model_name(func: Callable, include_file_name: bool = False) -> str:
+    """
+    :param func: The function to get the model name for.
+    :return: The name of the model.
+    """
     func_name = get_method_name(func)
     func_class_name = get_method_class_name_if_exists(func)
-    func_file_name = get_method_file_name(func)
-    model_name = func_file_name
-    model_name += f"_{func_class_name}" if func_class_name else ""
-    model_name += f"_{func_name}"
-    return os.path.join(model_dir, f"{model_name}.json")
+    if include_file_name:
+        func_file_name = get_method_file_name(func).split(os.sep)[-1].split('.')[0]
+        model_name = func_file_name + '_'
+    else:
+        model_name = ''
+    model_name += f"{func_class_name}_" if func_class_name else ""
+    model_name += f"{func_name}"
+    return model_name
+
+
+def extract_bracket_arguments(val: str) -> List[str]:
+    """
+    Extract arguments inside brackets into a list.
+
+    :param val: The string containing brackets.
+    :return: List of arguments inside brackets.
+    """
+    if '[' not in val:
+        return [val]
+    args_start = val.find('[')
+    args_end = val.rfind(']')
+    if args_end == -1:
+        return [val]
+    base_type = val[:args_start]
+    args = val[args_start + 1:args_end].split(',')
+    args = [arg.strip() for arg in args]
+    return [base_type] + args
+
+
+def typing_hint_to_str(type_hint: Any) -> Tuple[str, List[str]]:
+    """
+    Convert a typing hint to a string.
+
+    :param type_hint: The typing hint to convert.
+    :return: The string representation of the typing hint.
+    """
+    val = (str(type_hint).strip("<>")
+           .replace("class ", "")
+           # .replace("typing.", "")
+           .replace("'", ""))
+    all_args = []
+    if '[' in val:
+        args = extract_bracket_arguments(val)
+        args_with_brackets = [arg for arg in args if '[' in arg]
+        all_args.extend([arg for arg in args if '[' not in arg])
+        while args_with_brackets:
+            for arg in args:
+                if '[' in arg:
+                    sub_args = extract_bracket_arguments(arg)
+                    args_with_brackets.remove(arg)
+                    all_args.extend([sarg for sarg in sub_args if '[' not in sarg])
+                    args_with_brackets.extend([sarg for sarg in sub_args if '[' in sarg])
+                elif arg not in all_args:
+                    all_args.append(arg)
+            args = args_with_brackets
+        for arg in all_args:
+            val = val.replace(arg, arg.split('.')[-1])
+    else:
+        val = val.split('.')[-1]
+    return val, all_args
 
 
 def get_method_args_as_dict(method: Callable, *args, **kwargs) -> Dict[str, Any]:
@@ -632,6 +711,8 @@ def get_method_args_as_dict(method: Callable, *args, **kwargs) -> Dict[str, Any]
     :return: A dictionary of the arguments.
     """
     func_arg_names = method.__code__.co_varnames
+    func_arg_names = list(map(lambda arg_name: f"{arg_name}_" if arg_name in ["self", "cls"] else arg_name,
+                              func_arg_names))
     func_arg_values = args + tuple(kwargs.values())
     return dict(zip(func_arg_names, func_arg_values))
 
@@ -653,8 +734,27 @@ def get_method_class_name_if_exists(method: Callable) -> Optional[str]:
     :param method: The method to get the class name of.
     :return: The class name of the method.
     """
-    if hasattr(method, "__self__") and hasattr(method.__self__, "__class__"):
-        return method.__self__.__class__.__name__
+    if hasattr(method, "__self__"):
+        if hasattr(method.__self__, "__class__"):
+            return method.__self__.__class__.__name__
+    return method.__qualname__.split('.')[0] if hasattr(method, "__qualname__") else None
+
+
+def get_method_class_if_exists(method: Callable, *args) -> Optional[Type]:
+    """
+    Get the class of a method if it has one.
+
+    :param method: The method to get the class of.
+    :return: The class of the method, if it exists otherwise None.
+    """
+    if hasattr(method, "__self__"):
+        if hasattr(method.__self__, "__class__"):
+            return method.__self__.__class__
+    elif method.__code__.co_varnames:
+        if method.__code__.co_varnames[0] == 'self':
+            return args[0].__class__
+        elif method.__code__.co_varnames[0] == 'cls':
+            return args[0]
     return None
 
 
@@ -839,7 +939,25 @@ class SubclassJSONSerializer:
     load = from_json_file
 
 
-def copy_case(case: Union[Case, SQLTable]) -> Union[Case, SQLTable]:
+def _pickle_thread(thread_obj) -> Any:
+    """Return a plain object with user-defined attributes but no thread behavior."""
+
+    class DummyThread:
+        pass
+
+    dummy = DummyThread()
+    # Copy only non-thread-related attributes
+    for attr, value in thread_obj.__dict__.items():
+        print(attr)
+        if not attr.startswith("_"):  # Skip internal Thread attributes
+            setattr(dummy, attr, value)
+    return dummy
+
+
+copyreg.pickle(threading.Thread, _pickle_thread)
+
+
+def copy_case(case: Union[Case, SQLTable]) -> Union[Case, SQLTable, Any]:
     """
     Copy a case.
 
@@ -849,7 +967,18 @@ def copy_case(case: Union[Case, SQLTable]) -> Union[Case, SQLTable]:
     if isinstance(case, SQLTable):
         return copy_orm_instance_with_relationships(case)
     else:
-        return deepcopy(case)
+        # copy the case recursively for 1 level
+        # try:
+        #     case_copy = deepcopy(case)
+        # except Exception as e:
+        case_copy = copy(case)
+        for attr in dir(case):
+            if attr.startswith("_") or callable(getattr(case, attr)):
+                continue
+            attr_value = getattr(case, attr)
+            if is_iterable(attr_value):
+                setattr(case_copy, attr, copy(attr_value))
+        return case_copy
 
 
 def copy_orm_instance(instance: SQLTable) -> SQLTable:
@@ -908,7 +1037,7 @@ def get_value_type_from_type_hint(attr_name: str, obj: Any) -> Type:
     return attr_value_type
 
 
-def get_hint_for_attribute(attr_name: str, obj: Any) -> Tuple[Optional[Any], Optional[Any], Tuple[Any]]:
+def get_hint_for_attribute(attr_name: str, obj: Any) -> Tuple[Optional[Type], Optional[Type], Tuple[Type]]:
     """
     Get the type hint for an attribute of an object.
 
@@ -928,12 +1057,23 @@ def get_hint_for_attribute(attr_name: str, obj: Any) -> Tuple[Optional[Any], Opt
             hint = get_type_hints(obj.__class__)[attr_name]
         except KeyError:
             hint = type(class_attr)
-    origin = get_origin(hint)
-    args = get_args(hint)
+    origin, args = get_origin_and_args_from_type_hint(hint)
+    return origin, origin, args
+
+
+def get_origin_and_args_from_type_hint(type_hint: Type) -> Tuple[Optional[Type], Tuple[Type]]:
+    """
+    Get the origin and arguments from a type hint.W
+
+    :param type_hint: The type hint to get the origin and arguments from.
+    :return: The origin and arguments of the type hint.
+    """
+    origin = get_origin(type_hint)
+    args = get_args(type_hint)
     if origin is Mapped:
-        return args[0], get_origin(args[0]), get_args(args[0])
+        return get_origin(args[0]), get_args(args[0])
     else:
-        return hint, origin, args
+        return origin, args
 
 
 def table_rows_as_str(row_dict: Dict[str, Any], columns_per_row: int = 9):
@@ -951,6 +1091,7 @@ def table_rows_as_str(row_dict: Dict[str, Any], columns_per_row: int = 9):
     all_table_rows = []
     for row_keys, row_values in zip(keys, values):
         row_values = [str(v) if v is not None else "" for v in row_values]
+        row_values = [v.lower() if v in ["True", "False"] else v for v in row_values]
         table = tabulate([row_values], headers=row_keys, tablefmt='plain', maxcolwidths=[20] * len(row_keys))
         all_table_rows.append(table)
     return "\n".join(all_table_rows)
@@ -1100,7 +1241,7 @@ def get_all_subclasses(cls: Type) -> Dict[str, Type]:
     return all_subclasses
 
 
-def make_set(value: Any) -> Set[Any]:
+def make_set(value: Any) -> Set:
     """
     Make a set from a value.
 
@@ -1205,6 +1346,9 @@ def draw_tree(root: Node, fig: plt.Figure):
     """
     Draw the tree using matplotlib and networkx.
     """
+    if matplotlib.get_backend().lower() not in ['qt5agg', 'qt4agg', 'qt6agg']:
+        matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
+
     if root is None:
         return
     fig.clf()

{ripple_down_rules-0.2.3.dist-info → ripple_down_rules-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.2.3
+Version: 0.3.0
 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.3.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/datasets.py,sha256=zi5LVNA3oYUYL26HVUgOV8lKQ-wSmaJeOKHptdJ8A3E,6667
+ripple_down_rules/experts.py,sha256=8wTInaKum38mH5r5esw7tXq_iL15-JP2tf5VIHHBmpw,6229
+ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
+ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
+ripple_down_rules/prompt.py,sha256=KmlMRZRKqoyYIinp9l09LWL7e41DsqsGNcVbHRjebhg,23122
+ripple_down_rules/rdr.py,sha256=7Ir3jYqAf2qZwi0Quz-ZMc3jreiSADo9xfAfLj2gbLM,43491
+ripple_down_rules/rdr_decorators.py,sha256=VdmE0JrE8j89b6Af1R1tLZiKfy3h1VCvhAUefN_FLLQ,6753
+ripple_down_rules/rules.py,sha256=QQy7NBG6mKiowxVG_LjQJBxLTDW2hMyx5zAgwUxdCMM,17183
+ripple_down_rules/utils.py,sha256=SXNkIA9k75yKbfCAWQzq4XVxh3CpcxqSistnVFY3gBQ,48917
+ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
+ripple_down_rules/datastructures/callable_expression.py,sha256=jA7424_mWPbOoPICW3eLMX0-ypxnsW6gOqxrJ7JpDbE,11610
+ripple_down_rules/datastructures/case.py,sha256=oC8OSdhXvHE-Zx1IIQlad-fsKzQQqr6MZBW24c-dbeU,15191
+ripple_down_rules/datastructures/dataclasses.py,sha256=GWnUF4h4zfNHSsyBIz3L9y8sLkrXRv0FK_OxzzLc8L8,8183
+ripple_down_rules/datastructures/enums.py,sha256=sOEKvsmcFUnztScFOGmrxgrBNeIYHfV_CeQ5_Sj62so,5368
+ripple_down_rules-0.3.0.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.3.0.dist-info/METADATA,sha256=f-xZg62otuqgnzlf4Bwzt0ns25WQLWl2RgIARt9v-tk,42576
+ripple_down_rules-0.3.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+ripple_down_rules-0.3.0.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.3.0.dist-info/RECORD,,

{ripple_down_rules-0.2.3.dist-info → ripple_down_rules-0.3.0.dist-info}/WHEEL

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

ripple_down_rules-0.2.3.dist-info/RECORD

@@ -1,20 +0,0 @@
-ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules/datasets.py,sha256=mjJh1GLD_5qMgHaukdDWSGphXS9k_BPEF001ZXPchr8,4687
-ripple_down_rules/experts.py,sha256=JGVvSNiWhm4FpRpg76f98tl8Ii_C7x_aWD9FxD-JDLQ,6130
-ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
-ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
-ripple_down_rules/prompt.py,sha256=ReXnZ6OraFPqK5kDfAqH8d4SRPYiQ5d4ESk0js_MM9c,16150
-ripple_down_rules/rdr.py,sha256=vxNZckp6sLAUD92JQgfCzhBhg9CXfMZ_7W4VgrIUFjU,43366
-ripple_down_rules/rdr_decorators.py,sha256=8SclpceI3EtrsbuukWJu8HGLh7Q1ZCgYGLX-RPlG-w0,2018
-ripple_down_rules/rules.py,sha256=QQy7NBG6mKiowxVG_LjQJBxLTDW2hMyx5zAgwUxdCMM,17183
-ripple_down_rules/utils.py,sha256=EdVdIf93TAqbxRTzbf_1422FjenRSI4MI_Ecp3e10z8,44007
-ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
-ripple_down_rules/datastructures/callable_expression.py,sha256=qVo8baEI_seeg6V23wmsctYdWj_tJJEOTkHeUc04Wvw,10912
-ripple_down_rules/datastructures/case.py,sha256=nJDKOjyhGLx4gt0sHxJNxBLdy9X2SLcDn89_SmKzwoc,14035
-ripple_down_rules/datastructures/dataclasses.py,sha256=BUr0T0CCh98sdsW2CVAXGk2oWqfemM7w1t91QKvg_KU,6171
-ripple_down_rules/datastructures/enums.py,sha256=hlE6LAa1jUafnG_6UazvaPDfhC1ClI7hKvD89zOyAO8,4661
-ripple_down_rules-0.2.3.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.2.3.dist-info/METADATA,sha256=58UZ0WaNhQOguD_oiFOrHkFWS-hydrMeA6nE3KbRT5Q,42576
-ripple_down_rules-0.2.3.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-ripple_down_rules-0.2.3.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.2.3.dist-info/RECORD,,