ripple-down-rules 0.1.21__py3-none-any.whl → 0.1.61__py3-none-any.whl

ripple_down_rules/rules.py

@@ -1,14 +1,18 @@
 from __future__ import annotations
 
+import re
 from abc import ABC, abstractmethod
 from enum import Enum
 
 from anytree import NodeMixin
 from typing_extensions import List, Optional, Self, Union, Dict, Any
 
-from .datastructures import CallableExpression, Case, SQLTable
+from .datastructures.callable_expression import CallableExpression
+from .datastructures.case import Case
+from sqlalchemy.orm import DeclarativeBase as SQLTable
 from .datastructures.enums import RDREdge, Stop
-from .utils import SubclassJSONSerializer, is_iterable, get_full_class_name
+from .utils import SubclassJSONSerializer, is_iterable, get_full_class_name, conclusion_to_json, \
+    get_rule_conclusion_as_source_code
 
 
 class Rule(NodeMixin, SubclassJSONSerializer, ABC):
@@ -41,6 +45,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         self.conditions = conditions if conditions else None
         self.conclusion_name: Optional[str] = conclusion_name
         self.json_serialization: Optional[Dict[str, Any]] = None
+        self._name: Optional[str] = None
 
     def _post_detach(self, parent):
         """
@@ -79,43 +84,48 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
 
         :param parent_indent: The indentation of the parent rule.
         """
-        if isinstance(self.conclusion, CallableExpression):
-            conclusion = self.conclusion.parsed_user_input
-        elif isinstance(self.conclusion, Enum):
-            conclusion = str(self.conclusion)
-        else:
-            conclusion = self.conclusion
-        return self._conclusion_source_code_clause(conclusion, parent_indent=parent_indent)
+        conclusion = self.conclusion
+        if isinstance(conclusion, CallableExpression):
+            if self.conclusion.user_input is not None:
+                conclusion = self.conclusion.user_input
+            else:
+                conclusion = self.conclusion.conclusion
+        if isinstance(conclusion, Enum):
+            conclusion = str(conclusion)
+        return self._conclusion_source_code(conclusion, parent_indent=parent_indent)
 
     @abstractmethod
-    def _conclusion_source_code_clause(self, conclusion: Any, parent_indent: str = "") -> str:
+    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
         pass
 
-    def write_condition_as_source_code(self, parent_indent: str = "") -> str:
+    def write_condition_as_source_code(self, parent_indent: str = "", defs_file: Optional[str] = None) -> str:
         """
         Get the source code representation of the conditions of the rule.
 
         :param parent_indent: The indentation of the parent rule.
+        :param defs_file: The file to write the conditions to if they are a definition.
         """
         if_clause = self._if_statement_source_code_clause()
-        return f"{parent_indent}{if_clause} {self.conditions.parsed_user_input}:\n"
+        if '\n' not in self.conditions.user_input:
+            return f"{parent_indent}{if_clause} {self.conditions.user_input}:\n"
+        elif "def " in self.conditions.user_input:
+            if defs_file is None:
+                raise ValueError("Cannot write conditions to source code as definitions python file was not given.")
+            # This means the conditions are a definition that should be written and then called
+            conditions_lines = self.conditions.user_input.split('\n')
+            # use regex to replace the function name
+            new_function_name = f"def conditions_{id(self)}"
+            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")
+            return f"\n{parent_indent}{if_clause} {new_function_name.replace('def ', '')}(case):\n"
 
     @abstractmethod
     def _if_statement_source_code_clause(self) -> str:
         pass
 
     def _to_json(self) -> Dict[str, Any]:
-        def conclusion_to_json(conclusion):
-            if is_iterable(conclusion):
-                conclusions = {'_type': get_full_class_name(type(conclusion)), 'value': []}
-                for c in conclusion:
-                    conclusions['value'].append(conclusion_to_json(c))
-            elif hasattr(conclusion, 'to_json'):
-                conclusions = conclusion.to_json()
-            else:
-                conclusions = {'_type': get_full_class_name(type(conclusion)), 'value': conclusion}
-            return conclusions
-
         json_serialization = {"conditions": self.conditions.to_json(),
                               "conclusion": conclusion_to_json(self.conclusion),
                               "parent": self.parent.json_serialization if self.parent else None,
@@ -137,7 +147,14 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         """
         Get the name of the rule, which is the conditions and the conclusion.
         """
-        return self.__str__()
+        return self._name if self._name is not None else self.__str__()
+
+    @name.setter
+    def name(self, new_name: str):
+        """
+        Set the name of the rule.
+        """
+        self._name = new_name
 
     def __str__(self, sep="\n"):
         """
@@ -247,8 +264,13 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
         loaded_rule.alternative = SingleClassRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code_clause(self, conclusion: Any, parent_indent: str = "") -> str:
-        return f"{parent_indent}{' ' * 4}return {conclusion}\n"
+    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
+        conclusion = str(conclusion)
+        indent = parent_indent + " " * 4
+        if '\n' not in conclusion:
+            return f"{indent}return {conclusion}\n"
+        else:
+            return get_rule_conclusion_as_source_code(self, conclusion, parent_indent=parent_indent)
 
     def _if_statement_source_code_clause(self) -> str:
         return "elif" if self.weight == RDREdge.Alternative.value else "if"
@@ -293,7 +315,7 @@ class MultiClassStopRule(Rule, HasAlternativeRule):
         loaded_rule.alternative = MultiClassStopRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code_clause(self, conclusion: Any, parent_indent: str = "") -> str:
+    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
         return f"{parent_indent}{' ' * 4}pass\n"
 
     def _if_statement_source_code_clause(self) -> str:
@@ -338,12 +360,22 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
         loaded_rule.alternative = MultiClassTopRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code_clause(self, conclusion: Any, parent_indent: str = "") -> str:
-        if is_iterable(conclusion):
-            conclusion_str = "{" + ", ".join([str(c) for c in conclusion]) + "}"
+    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
+        conclusion_str = str(conclusion)
+        indent = parent_indent + " " * 4
+        statement = ""
+        if '\n' not in conclusion_str:
+            if is_iterable(conclusion):
+                conclusion_str = "{" + ", ".join([str(c) for c in conclusion]) + "}"
+            else:
+                conclusion_str = "{" + str(conclusion) + "}"
         else:
-            conclusion_str = "{" + str(conclusion) + "}"
-        statement = f"{parent_indent}{' ' * 4}conclusions.update({conclusion_str})\n"
+            conclusion_str = get_rule_conclusion_as_source_code(self, conclusion_str, parent_indent=parent_indent)
+            lines = conclusion_str.split("\n")
+            conclusion_str = lines[-2].replace("return ", "").strip()
+            statement += "\n".join(lines[:-2]) + "\n"
+
+        statement += f"{indent}conclusions.update(make_set({conclusion_str}))\n"
         if self.alternative is None:
             statement += f"{parent_indent}return conclusions\n"
         return statement

ripple_down_rules/utils.py

@@ -1,17 +1,20 @@
 from __future__ import annotations
 
 import ast
+import builtins
 import importlib
 import json
 import logging
 import os
-from abc import abstractmethod
+import re
 from collections import UserDict
 from copy import deepcopy
-from dataclasses import dataclass, is_dataclass, fields
+from dataclasses import is_dataclass, fields
+from types import NoneType
 
 import matplotlib
 import networkx as nx
+import requests
 from anytree import Node, RenderTree
 from anytree.exporter import DotExporter
 from matplotlib import pyplot as plt
@@ -22,11 +25,203 @@ from typing_extensions import Callable, Set, Any, Type, Dict, TYPE_CHECKING, get
     get_origin, get_args, Tuple, Optional, List, Union, Self
 
 if TYPE_CHECKING:
-    from .datastructures import Case
+    from .datastructures.case import Case
+    from .rules import Rule
+
+import ast
 
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def is_matching(rdr_classifier: Callable[[Any], Any], case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
+    """
+    :param rdr_classifier: The RDR classifier to check the prediction of.
+    :param case_query: The case query to check.
+    :param pred_cat: The predicted category.
+    :return: Whether the classifier prediction is matching case_query target or not.
+    """
+    if case_query.target is None:
+        return False
+    if pred_cat is None:
+        pred_cat = rdr_classifier(case_query.case)
+    if not isinstance(pred_cat, dict):
+        pred_cat = {case_query.attribute_name: pred_cat}
+    target = {case_query.attribute_name: case_query.target_value}
+    precision, recall = calculate_precision_and_recall(pred_cat, target)
+    return all(recall) and all(precision)
+
+
+def calculate_precision_and_recall(pred_cat: Dict[str, Any], target: Dict[str, Any]) -> Tuple[
+    List[bool], List[bool]]:
+    """
+    :param pred_cat: The predicted category.
+    :param target: The target category.
+    :return: The precision and recall of the classifier.
+    """
+    recall = []
+    precision = []
+    for pred_key, pred_value in pred_cat.items():
+        if pred_key not in target:
+            continue
+        precision.extend([v in make_set(target[pred_key]) for v in make_set(pred_value)])
+    for target_key, target_value in target.items():
+        if target_key not in pred_cat:
+            recall.append(False)
+            continue
+        recall.extend([v in make_set(pred_cat[target_key]) for v in make_set(target_value)])
+    return precision, recall
+
+
+def get_rule_conclusion_as_source_code(rule: Rule, conclusion: str, parent_indent: str = "") -> str:
+    """
+    Convert the conclusion of a rule to source code.
+
+    :param rule: The rule to get the conclusion from.
+    :param conclusion: The conclusion to convert to source code.
+    :param parent_indent: The indentation to use for the source code.
+    :return: The source code of the conclusion.
+    """
+    indent = f"{parent_indent}{' ' * 4}"
+    if "def " in conclusion:
+        # This means the conclusion is a definition that should be written and then called
+        conclusion_lines = conclusion.split('\n')
+        # use regex to replace the function name
+        new_function_name = f"def conclusion_{id(rule)}"
+        conclusion_lines[0] = re.sub(r"def (\w+)", new_function_name, conclusion_lines[0])
+        conclusion_lines = [f"{indent}{line}" for line in conclusion_lines]
+        conclusion_lines.append(f"{indent}return {new_function_name.replace('def ', '')}(case)\n")
+        return "\n".join(conclusion_lines)
+    else:
+        raise ValueError(f"Conclusion is format is not valid, it should be a one line string or "
+                         f"contain a function definition. Instead got:\n{conclusion}\n")
+
+
+def ask_llm(prompt):
+    try:
+        response = requests.post("http://localhost:11434/api/generate", json={
+            "model": "codellama:7b-instruct",  # or "phi"
+            "prompt": prompt,
+            "stream": False,
+        })
+        result = response.json()
+        return result.get("response", "").strip()
+    except Exception as e:
+        return f"❌ Local LLM error: {e}"
+
+
+def get_case_attribute_type(original_case: Any, attribute_name: str,
+                            known_value: Optional[Any] = None) -> Type:
+    """
+    :param original_case: The case to get the attribute from.
+    :param attribute_name: The name of the attribute.
+    :param known_value: A known value of the attribute.
+    :return: The type of the attribute.
+    """
+    if known_value is not None:
+        return type(known_value)
+    elif hasattr(original_case, attribute_name):
+        hint, origin, args = get_hint_for_attribute(attribute_name, original_case)
+        if origin is not None:
+            origin = typing_to_python_type(origin)
+        if origin == Union:
+            if len(args) == 2:
+                if args[1] is type(None):
+                    return typing_to_python_type(args[0])
+                elif args[0] is type(None):
+                    return typing_to_python_type(args[1])
+            elif len(args) == 1:
+                return typing_to_python_type(args[0])
+            else:
+                raise ValueError(f"Union with more than 2 types is not supported: {args}")
+        elif origin is not None:
+            return origin
+        if hint is not None:
+            return typing_to_python_type(hint)
+
+
+def conclusion_to_json(conclusion):
+    if is_iterable(conclusion):
+        conclusions = {'_type': get_full_class_name(type(conclusion)), 'value': []}
+        for c in conclusion:
+            conclusions['value'].append(conclusion_to_json(c))
+    elif hasattr(conclusion, 'to_json'):
+        conclusions = conclusion.to_json()
+    else:
+        conclusions = {'_type': get_full_class_name(type(conclusion)), 'value': conclusion}
+    return conclusions
+
+
+def contains_return_statement(source: str) -> bool:
+    """
+    :param source: The source code to check.
+    :return: True if the source code contains a return statement, False otherwise.
+    """
+    try:
+        tree = ast.parse(source)
+        for node in tree.body:
+            if isinstance(node, ast.Return):
+                return True
+        return False
+    except SyntaxError:
+        return False
+
+
+def get_names_used(node):
+    return {n.id for n in ast.walk(node) if isinstance(n, ast.Name)}
+
+
+def extract_dependencies(code_lines):
+    full_code = '\n'.join(code_lines)
+    tree = ast.parse(full_code)
+    final_stmt = tree.body[-1]
+
+    if not isinstance(final_stmt, ast.Return):
+        raise ValueError("Last line is not a return statement")
+
+    needed = get_names_used(final_stmt.value)
+    required_lines = []
+    line_map = {id(node): i for i, node in enumerate(tree.body)}
+
+    def handle_stmt(stmt, needed):
+        keep = False
+        if isinstance(stmt, ast.Assign):
+            targets = [t.id for t in stmt.targets if isinstance(t, ast.Name)]
+            if any(t in needed for t in targets):
+                needed.update(get_names_used(stmt.value))
+                keep = True
+        elif isinstance(stmt, ast.AugAssign):
+            if isinstance(stmt.target, ast.Name) and stmt.target.id in needed:
+                needed.update(get_names_used(stmt.value))
+                keep = True
+        elif isinstance(stmt, ast.FunctionDef):
+            if stmt.name in needed:
+                for n in ast.walk(stmt):
+                    if isinstance(n, ast.Name):
+                        needed.add(n.id)
+                keep = True
+        elif isinstance(stmt, (ast.For, ast.While, ast.If)):
+            # Check if any of the body statements interact with needed variables
+            for substmt in stmt.body + getattr(stmt, 'orelse', []):
+                if handle_stmt(substmt, needed):
+                    keep = True
+            # Also check the condition (test or iter)
+            if isinstance(stmt, ast.For):
+                if isinstance(stmt.target, ast.Name) and stmt.target.id in needed:
+                    keep = True
+                needed.update(get_names_used(stmt.iter))
+            elif isinstance(stmt, ast.If) or isinstance(stmt, ast.While):
+                needed.update(get_names_used(stmt.test))
+
+        return keep
+
+    for stmt in reversed(tree.body[:-1]):
+        if handle_stmt(stmt, needed):
+            required_lines.insert(0, code_lines[line_map[id(stmt)]])
+
+    required_lines.append(code_lines[-1])  # Always include return
+    return required_lines
+
+
 def serialize_dataclass(obj: Any) -> Union[Dict, Any]:
     """
     Recursively serialize a dataclass to a dictionary. If the dataclass contains any nested dataclasses, they will be
@@ -61,6 +256,7 @@ def deserialize_dataclass(data: dict) -> Any:
     :param data: The dictionary to deserialize.
     :return: The deserialized dataclass.
     """
+
     def recursive_load(obj):
         if isinstance(obj, dict) and "__dataclass__" in obj:
             module_name, class_name = obj["__dataclass__"].rsplit(".", 1)
@@ -219,6 +415,8 @@ def get_type_from_string(type_path: str):
     """
     module_path, class_name = type_path.rsplit(".", 1)
     module = importlib.import_module(module_path)
+    if module == builtins and class_name == 'NoneType':
+        return type(None)
     return getattr(module, class_name)
 
 
@@ -316,6 +514,8 @@ class SubclassJSONSerializer:
         data_type = get_type_from_string(data["_type"])
         if len(data) == 1:
             return data_type
+        if data_type == NoneType:
+            return None
         if data_type.__module__ == 'builtins':
             if is_iterable(data['value']) and not isinstance(data['value'], dict):
                 return data_type([cls.from_json(d) for d in data['value']])
@@ -443,6 +643,7 @@ def table_rows_as_str(row_dict: Dict[str, Any], columns_per_row: int = 9):
     values = [list(map(lambda i: i[1], row)) for row in all_items]
     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]
         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)
@@ -579,7 +780,7 @@ def get_all_subclasses(cls: Type) -> Dict[str, Type]:
     return all_subclasses
 
 
-def make_set(value: Any) -> Set:
+def make_set(value: Any) -> Set[Any]:
     """
     Make a set from a value.
 

{ripple_down_rules-0.1.21.dist-info → ripple_down_rules-0.1.61.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.21
+Version: 0.1.61
 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
@@ -709,7 +709,7 @@ Fit the SCRDR to the data, then classify one of the data cases to check if its c
 and render the tree to a file:
 
 ```Python
-from ripple_down_rules.datastructures import CaseQuery
+from ripple_down_rules.datastructures.dataclasses import CaseQuery
 from ripple_down_rules.rdr import SingleClassRDR
 from ripple_down_rules.datasets import load_zoo_dataset
 from ripple_down_rules.utils import render_tree
@@ -719,12 +719,13 @@ all_cases, targets = load_zoo_dataset()
 scrdr = SingleClassRDR()
 
 # Fit the SCRDR to the data
-case_queries = [CaseQuery(case, target=target) for case, target in zip(all_cases, targets)]
+case_queries = [CaseQuery(case, 'species', type(target), True, _target=target)
+                for case, target in zip(all_cases[:10], targets[:10])]
 scrdr.fit(case_queries, animate_tree=True)
 
 # Render the tree to a file
 render_tree(scrdr.start_rule, use_dot_exporter=True, filename="scrdr")
 
-cat = scrdr.fit_case(all_cases[50], targets[50])
+cat = scrdr.classify(all_cases[50])
 assert cat == targets[50]
 ```

ripple_down_rules-0.1.61.dist-info/RECORD

@@ -0,0 +1,20 @@
+ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/datasets.py,sha256=rCSpeFeu1gTuKESwjHUdQkPPvomI5OMRNGpbdKmHwMg,4639
+ripple_down_rules/experts.py,sha256=sA9Cmx9BlwlCFYRDDLz3VG6e5njujAFZEItSnnzrG5E,10490
+ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
+ripple_down_rules/helpers.py,sha256=AhqerAQoCdSovJ7SdQrNtAI_hYagKpLsy2nJQGA0bl0,1062
+ripple_down_rules/prompt.py,sha256=6g-WqMiOFp9QyAZDmiNbHbPjAeeJHb6ItLGdQAVxGKk,6063
+ripple_down_rules/rdr.py,sha256=VT7AWTDlLOyk2FILa4mHixdno2kXtk82m_pSY1CoEiE,48789
+ripple_down_rules/rdr_decorators.py,sha256=8SclpceI3EtrsbuukWJu8HGLh7Q1ZCgYGLX-RPlG-w0,2018
+ripple_down_rules/rules.py,sha256=KTB7kPnyyU9GuZhVe9ba25-3ICdzl46r9MFduckk-_Y,16147
+ripple_down_rules/utils.py,sha256=ppKTt3_O6JgmTqCdkjVBfuVaI6P7b4oRCSOmnBaqaVM,32110
+ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
+ripple_down_rules/datastructures/callable_expression.py,sha256=TW_u6CJfelW2CiJj9pWFpdOBNIxeEuhhsQEz_pLpFVE,9092
+ripple_down_rules/datastructures/case.py,sha256=A7qkl5W48zldTtA4m-NJRYEwlMBpo7uGugnriNwcY0E,13597
+ripple_down_rules/datastructures/dataclasses.py,sha256=inhTE4tlMrwVRcYDtqAaR0JlxlyD87JIUvXIu5H9Ioo,5860
+ripple_down_rules/datastructures/enums.py,sha256=l0Eu-TeJ6qB2XHoJycXmUgLw-3yUebQ8SsEbW8bBZdM,4543
+ripple_down_rules-0.1.61.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.1.61.dist-info/METADATA,sha256=fstYXWm2KIN0bmiUkJTD6UIDiGQGtjE-pt263bDgJqk,42576
+ripple_down_rules-0.1.61.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+ripple_down_rules-0.1.61.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.1.61.dist-info/RECORD,,

{ripple_down_rules-0.1.21.dist-info → ripple_down_rules-0.1.61.dist-info}/WHEEL

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

ripple_down_rules-0.1.21.dist-info/RECORD

@@ -1,20 +0,0 @@
-ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules/datasets.py,sha256=AzPtqUXuR1qLQNtRsWLsJ3gX2oIf8nIkFvmsmz7fHlw,4601
-ripple_down_rules/experts.py,sha256=Xz1U1Tdq7jrFlcVuSusaMB241AG9TEs7q101i59Xijs,10683
-ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
-ripple_down_rules/helpers.py,sha256=AhqerAQoCdSovJ7SdQrNtAI_hYagKpLsy2nJQGA0bl0,1062
-ripple_down_rules/prompt.py,sha256=z6KddZOsNiStptgCRNh2OVHHuH6Ooa2f-nsrgJH1qJ8,6311
-ripple_down_rules/rdr.py,sha256=NXVYIflUxcDzC5DDrK-l_ZT-sBmUV1ZgkznshSsJZYc,43508
-ripple_down_rules/rdr_decorators.py,sha256=8SclpceI3EtrsbuukWJu8HGLh7Q1ZCgYGLX-RPlG-w0,2018
-ripple_down_rules/rules.py,sha256=aM3Im4ePuFDlkuD2EKRtiVmYgoQ_sxlwcbzrDKqXAfs,14578
-ripple_down_rules/utils.py,sha256=9gPnRWlLye7FettI2QRWJx8oU9z3ckwdO5jopXK8b-8,24290
-ripple_down_rules/datastructures/__init__.py,sha256=zpmiYm4WkwNHaGdTIfacS7llN5d2xyU6U-saH_TpydI,103
-ripple_down_rules/datastructures/callable_expression.py,sha256=ac2TaMr0hiRX928GMcr3oTQic8KXXO4syLw4KV-Iehs,10515
-ripple_down_rules/datastructures/case.py,sha256=3Pl07jmYn94wdCVTaRZDmBPgyAsN1TjebvrE6-68MVU,13606
-ripple_down_rules/datastructures/dataclasses.py,sha256=AI-wqNy8y9QPg6lov0P-c5b8JXemuM4X62tIRhW-Gqs,4231
-ripple_down_rules/datastructures/enums.py,sha256=l0Eu-TeJ6qB2XHoJycXmUgLw-3yUebQ8SsEbW8bBZdM,4543
-ripple_down_rules-0.1.21.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.1.21.dist-info/METADATA,sha256=Jg_qdgg-DkAqblqWTisVcv1K3H8Thr_CjdeIX3UyLgE,42519
-ripple_down_rules-0.1.21.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-ripple_down_rules-0.1.21.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.1.21.dist-info/RECORD,,