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

ripple_down_rules/datastructures/callable_expression.py

@@ -9,7 +9,7 @@ from typing_extensions import Type, Optional, Any, List, Union, Tuple, Dict, Set
 
 from .case import create_case, Case
 from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string, conclusion_to_json, is_iterable, \
-    build_user_input_from_conclusion, encapsulate_user_input
+    build_user_input_from_conclusion, encapsulate_user_input, extract_function_source
 
 
 class VariableVisitor(ast.NodeVisitor):
@@ -109,7 +109,7 @@ class CallableExpression(SubclassJSONSerializer):
         if user_input is None:
             user_input = build_user_input_from_conclusion(conclusion)
         self.conclusion: Optional[Any] = conclusion
-        self.user_input: str = encapsulate_user_input(user_input, self.encapsulating_function)
+        self._user_input: str = encapsulate_user_input(user_input, self.encapsulating_function)
         if conclusion_type is not None:
             if is_iterable(conclusion_type):
                 conclusion_type = tuple(conclusion_type)
@@ -156,6 +156,35 @@ class CallableExpression(SubclassJSONSerializer):
                           f"return _cond1(case) and _cond2(case)")
         return CallableExpression(new_user_input, conclusion_type=self.conclusion_type)
 
+    def update_user_input_from_file(self, file_path: str, function_name: str):
+        """
+        Update the user input from a file.
+        """
+        new_function_body = extract_function_source(file_path, [function_name])[function_name]
+        if new_function_body is None:
+            return
+        self.user_input = self.encapsulating_function + '\n' + new_function_body
+
+    @property
+    def user_input(self):
+        """
+        Get the user input.
+        """
+        return self._user_input
+
+    @user_input.setter
+    def user_input(self, value: str):
+        """
+        Set the user input.
+        """
+        if value is not None:
+            self._user_input = encapsulate_user_input(value, self.encapsulating_function)
+            self.scope = get_used_scope(self.user_input, self.scope)
+            self.expression_tree = parse_string_to_expression(self.user_input)
+            self.code = compile_expression_to_code(self.expression_tree)
+            self.visitor = VariableVisitor()
+            self.visitor.visit(self.expression_tree)
+
     def __eq__(self, other):
         """
         Check if two callable expressions are equal.
@@ -225,7 +254,7 @@ 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'):
+    if not expression_str.startswith(CallableExpression.encapsulating_function):
         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)

ripple_down_rules/datastructures/enums.py

@@ -59,7 +59,7 @@ class PromptFor(Enum):
     """
     Prompt for rule conditions about a case.
     """
-    Conclusion: str = "conclusion"
+    Conclusion: str = "value"
     """
     Prompt for rule conclusion about a case.
     """

ripple_down_rules/prompt.py

@@ -1,27 +1,148 @@
 import ast
 import logging
+import os
+import subprocess
+import tempfile
 from _ast import AST
+from functools import cached_property
+from textwrap import indent, dedent
 
+from IPython.core.magic import register_line_magic, line_magic, Magics, magics_class
 from IPython.terminal.embed import InteractiveShellEmbed
 from traitlets.config import Config
-from typing_extensions import List, Optional, Tuple, Dict
+from typing_extensions import List, Optional, Tuple, Dict, Type, Union
 
 from .datastructures.enums import PromptFor
+from .datastructures.case import Case
 from .datastructures.callable_expression import CallableExpression, parse_string_to_expression
 from .datastructures.dataclasses import CaseQuery
-from .utils import extract_dependencies, contains_return_statement, make_set
+from .utils import extract_dependencies, contains_return_statement, make_set, get_imports_from_scope, make_list, \
+    get_import_from_type, get_imports_from_types, is_iterable, extract_function_source, encapsulate_user_input
+
+
+@magics_class
+class MyMagics(Magics):
+    def __init__(self, shell, scope, output_type: Optional[Type] = None, func_name: str = "user_case",
+                 func_doc: str = "User defined function to be executed on the case.",
+                 code_to_modify: Optional[str] = None):
+        super().__init__(shell)
+        self.scope = scope
+        self.temp_file_path = None
+        self.func_name = func_name
+        self.func_doc = func_doc
+        self.code_to_modify = code_to_modify
+        self.output_type = make_list(output_type) if output_type is not None else None
+        self.user_edit_line = 0
+        self.function_signature: Optional[str] = None
+        self.build_function_signature()
+
+    @line_magic
+    def edit_case(self, line):
+
+        boilerplate_code = self.build_boilerplate_code()
+
+        self.write_to_file(boilerplate_code)
+
+        print(f"Opening {self.temp_file_path} in PyCharm...")
+        subprocess.Popen(["pycharm", "--line", str(self.user_edit_line), self.temp_file_path])
+
+    def build_boilerplate_code(self):
+        imports = self.get_imports()
+        self.build_function_signature()
+        if self.code_to_modify is not None:
+            body = indent(dedent(self.code_to_modify), '    ')
+        else:
+            body = "    # Write your code here\n    pass"
+        boilerplate = f"""{imports}\n\n{self.function_signature}\n    \"\"\"{self.func_doc}\"\"\"\n{body}"""
+        self.user_edit_line = imports.count('\n')+6
+        return boilerplate
+
+    def build_function_signature(self):
+        if self.output_type is None:
+            output_type_hint = ""
+        elif len(self.output_type) == 1:
+            output_type_hint = f" -> {self.output_type[0].__name__}"
+        else:
+            output_type_hint = f" -> Union[{', '.join([t.__name__ for t in self.output_type])}]"
+        self.function_signature = f"def {self.func_name}(case: {self.case_type.__name__}){output_type_hint}:"
+
+    def write_to_file(self, code: str):
+        tmp = tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix=".py",
+                                          dir=os.path.dirname(self.scope['__file__']))
+        tmp.write(code)
+        tmp.flush()
+        self.temp_file_path = tmp.name
+        tmp.close()
+
+    def get_imports(self):
+        case_type_import = f"from {self.case_type.__module__} import {self.case_type.__name__}"
+        if self.output_type is None:
+            output_type_imports = [f"from typing_extensions import Any"]
+        else:
+            output_type_imports = get_imports_from_types(self.output_type)
+            if len(self.output_type) > 1:
+                output_type_imports.append("from typing_extensions import Union")
+        print(output_type_imports)
+        imports = get_imports_from_scope(self.scope)
+        imports = [i for i in imports if ("get_ipython" not in i)]
+        if case_type_import not in imports:
+            imports.append(case_type_import)
+        imports.extend([oti for oti in output_type_imports if oti not in imports])
+        imports = set(imports)
+        return '\n'.join(imports)
+
+    @cached_property
+    def case_type(self) -> Type:
+        """
+        Get the type of the case object in the current scope.
+
+        :return: The type of the case object.
+        """
+        case = self.scope['case']
+        return case._obj_type if isinstance(case, Case) else type(case)
+
+    @line_magic
+    def load_case(self, line):
+        if not self.temp_file_path:
+            print("No file to load. Run %edit_case first.")
+            return
+
+        with open(self.temp_file_path, 'r') as f:
+            source = f.read()
+
+        tree = ast.parse(source)
+        for node in tree.body:
+            if isinstance(node, ast.FunctionDef) and node.name == self.func_name:
+                exec_globals = {}
+                exec(source, self.scope, exec_globals)
+                user_function = exec_globals[self.func_name]
+                self.shell.user_ns[self.func_name] = user_function
+                print(f"Loaded `{self.func_name}` function into user namespace.")
+                return
+
+        print(f"Function `{self.func_name}` not found.")
 
 
 class CustomInteractiveShell(InteractiveShellEmbed):
-    def __init__(self, **kwargs):
+    def __init__(self, output_type: Union[Type, Tuple[Type], None] = None, func_name: Optional[str] = None,
+                 func_doc: Optional[str] = None, code_to_modify: Optional[str] = None, **kwargs):
         super().__init__(**kwargs)
+        keys = ['output_type', 'func_name', 'func_doc', 'code_to_modify']
+        values = [output_type, func_name, func_doc, code_to_modify]
+        magics_kwargs = {key: value for key, value in zip(keys, values) if value is not None}
+        self.my_magics = MyMagics(self, self.user_ns, **magics_kwargs)
+        self.register_magics(self.my_magics)
         self.all_lines = []
 
     def run_cell(self, raw_cell: str, **kwargs):
         """
         Override the run_cell method to capture return statements.
         """
-        if contains_return_statement(raw_cell):
+        if contains_return_statement(raw_cell) and 'def ' not in raw_cell:
+            if self.my_magics.func_name in raw_cell:
+                self.all_lines = extract_function_source(self.my_magics.temp_file_path,
+                                                         self.my_magics.func_name,
+                                                         join_lines=False)[self.my_magics.func_name]
             self.all_lines.append(raw_cell)
             print("Exiting shell on `return` statement.")
             self.history_manager.store_inputs(line_num=self.execution_count, source=raw_cell)
@@ -38,16 +159,31 @@ class IPythonShell:
     Create an embedded Ipython shell that can be used to prompt the user for input.
     """
 
-    def __init__(self, scope: Optional[Dict] = None, header: Optional[str] = None):
+    def __init__(self, scope: Optional[Dict] = None, header: Optional[str] = None,
+                 output_type: Optional[Type] = None, prompt_for: Optional[PromptFor] = None,
+                 attribute_name: Optional[str] = None, attribute_type: Optional[Type] = None,
+                 code_to_modify: Optional[str] = None):
         """
         Initialize the Ipython shell with the given scope and header.
 
         :param scope: The scope to use for the shell.
         :param header: The header to display when the shell is started.
+        :param output_type: The type of the output from user input.
+        :param prompt_for: The type of information to ask the user about.
+        :param attribute_name: The name of the attribute of the case.
+        :param attribute_type: The type of the attribute of the case.
+        :param code_to_modify: The code to modify. If given, will be used as a start for user to modify.
         """
         self.scope: Dict = scope or {}
         self.header: str = header or ">>> Embedded Ipython Shell"
+        self.output_type: Optional[Type] = output_type
+        self.prompt_for: Optional[PromptFor] = prompt_for
+        self.attribute_name: Optional[str] = attribute_name
+        self.attribute_type: Optional[Type] = attribute_type
+        self.code_to_modify: Optional[str] = code_to_modify
         self.user_input: Optional[str] = None
+        self.func_name: str = ""
+        self.func_doc: str = ""
         self.shell: CustomInteractiveShell = self._init_shell()
         self.all_code_lines: List[str] = []
 
@@ -56,9 +192,49 @@ class IPythonShell:
         Initialize the Ipython shell with a custom configuration.
         """
         cfg = Config()
-        shell = CustomInteractiveShell(config=cfg, user_ns=self.scope, banner1=self.header)
+        self.build_func_name_and_doc()
+        shell = CustomInteractiveShell(config=cfg, user_ns=self.scope, banner1=self.header,
+                                       output_type=self.output_type, func_name=self.func_name, func_doc=self.func_doc,
+                                       code_to_modify=self.code_to_modify)
         return shell
 
+    def build_func_name_and_doc(self) -> Tuple[str, str]:
+        """
+        Build the function name and docstring for the user-defined function.
+
+        :return: A tuple containing the function name and docstring.
+        """
+        case = self.scope['case']
+        case_type = case._obj_type if isinstance(case, Case) else type(case)
+        self.func_name = self.build_func_name(case_type)
+        self.func_doc = self.build_func_doc(case_type)
+
+    def build_func_doc(self, case_type: Type):
+        if self.prompt_for == PromptFor.Conditions:
+            func_doc = (f"Get conditions on whether it's possible to conclude a value"
+                        f" for {case_type.__name__}.{self.attribute_name}")
+        else:
+            func_doc = f"Get possible value(s) for {case_type.__name__}.{self.attribute_name}"
+        if is_iterable(self.attribute_type):
+            possible_types = [t.__name__ for t in self.attribute_type if t not in [list, set]]
+            func_doc += f" of types list/set of {' and/or '.join(possible_types)}"
+        else:
+            func_doc += f" of type {self.attribute_type.__name__}"
+        return func_doc
+
+    def build_func_name(self, case_type: Type):
+        func_name = f"get_{self.prompt_for.value.lower()}_for"
+        func_name += f"_{case_type.__name__}"
+        if self.attribute_name is not None:
+            func_name += f"_{self.attribute_name}"
+        if is_iterable(self.attribute_type):
+            output_names = [f"{t.__name__}" for t in self.attribute_type if t not in [list, set]]
+        else:
+            output_names = [self.attribute_type.__name__] if self.attribute_type is not None else None
+        if output_names is not None:
+            func_name += '_of_type_' + '_'.join(output_names)
+        return func_name.lower()
+
     def run(self):
         """
         Run the embedded shell.
@@ -83,7 +259,12 @@ class IPythonShell:
             if len(self.all_code_lines) == 1 and self.all_code_lines[0].strip() == '':
                 self.user_input = None
             else:
+                import pdb; pdb.set_trace()
                 self.user_input = '\n'.join(self.all_code_lines)
+                self.user_input = encapsulate_user_input(self.user_input, self.shell.my_magics.function_signature,
+                                                         self.func_doc)
+                if f"return {self.func_name}(case)" not in self.user_input:
+                    self.user_input = self.user_input.strip() + f"\nreturn {self.func_name}(case)"
 
 
 def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, prompt_str: Optional[str] = None)\
@@ -96,8 +277,11 @@ def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, pro
     :param prompt_str: The prompt string to display to the user.
     :return: A callable expression that takes a case and executes user expression on it.
     """
+    prev_user_input: Optional[str] = None
     while True:
-        user_input, expression_tree = prompt_user_about_case(case_query, prompt_for, prompt_str)
+        user_input, expression_tree = prompt_user_about_case(case_query, prompt_for, prompt_str,
+                                                             code_to_modify=prev_user_input)
+        prev_user_input = '\n'.join(user_input.split('\n')[2:-1])
         if user_input is None:
             if prompt_for == PromptFor.Conclusion:
                 print("No conclusion provided. Exiting.")
@@ -109,7 +293,11 @@ def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, pro
         callable_expression = CallableExpression(user_input, conclusion_type, expression_tree=expression_tree,
                                                  scope=case_query.scope)
         try:
-            callable_expression(case_query.case)
+            result = callable_expression(case_query.case)
+            result = make_list(result)
+            if len(result) == 0:
+                print(f"The given expression gave an empty result for case {case_query.name}, please modify")
+                continue
             break
         except Exception as e:
             logging.error(e)
@@ -118,19 +306,24 @@ def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, pro
 
 
 def prompt_user_about_case(case_query: CaseQuery, prompt_for: PromptFor,
-                           prompt_str: Optional[str] = None) -> Tuple[Optional[str], Optional[AST]]:
+                           prompt_str: Optional[str] = None,
+                           code_to_modify: Optional[str] = None) -> Tuple[Optional[str], Optional[AST]]:
     """
     Prompt the user for input.
 
     :param case_query: The case query to prompt the user for.
     :param prompt_for: The type of information the user should provide for the given case.
     :param prompt_str: The prompt string to display to the user.
+    :param code_to_modify: The code to modify. If given will be used as a start for user to modify.
     :return: The user input, and the executable expression that was parsed from the user input.
     """
     if prompt_str is None:
         prompt_str = f"Give {prompt_for} for {case_query.name}"
     scope = {'case': case_query.case, **case_query.scope}
-    shell = IPythonShell(scope=scope, header=prompt_str)
+    output_type = case_query.attribute_type if prompt_for == PromptFor.Conclusion else bool
+    shell = IPythonShell(scope=scope, header=prompt_str, output_type=output_type, prompt_for=prompt_for,
+                         attribute_name=case_query.attribute_name, attribute_type=case_query.attribute_type,
+                         code_to_modify=code_to_modify)
     return prompt_user_input_and_parse_to_expression(shell=shell)
 
 

ripple_down_rules/rdr.py

@@ -4,25 +4,23 @@ import importlib
 import sys
 from abc import ABC, abstractmethod
 from copy import copy
-from dataclasses import is_dataclass
 from io import TextIOWrapper
 from types import ModuleType
 
 from matplotlib import pyplot as plt
-from ordered_set import OrderedSet
 from sqlalchemy.orm import DeclarativeBase as SQLTable
 from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tuple, Callable, Set
 
 from .datastructures.callable_expression import CallableExpression
 from .datastructures.case import Case, CaseAttribute, create_case
 from .datastructures.dataclasses import CaseQuery
-from .datastructures.enums import MCRDRMode, PromptFor
-from .experts import Expert, Human
+from .datastructures.enums import MCRDRMode
+from .experts import Expert
 from .helpers import is_matching
 from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
 from .utils import draw_tree, make_set, copy_case, \
-    SubclassJSONSerializer, is_iterable, make_list, get_type_from_string, \
-    get_case_attribute_type, is_conflicting, update_case
+    SubclassJSONSerializer, make_list, get_type_from_string, \
+    is_conflicting, update_case, get_imports_from_scope, extract_function_source
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -102,11 +100,12 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         return self.classify(case)
 
     @abstractmethod
-    def classify(self, case: Union[Case, SQLTable]) -> Optional[CaseAttribute]:
+    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False) -> Optional[CaseAttribute]:
         """
         Classify a case.
 
         :param case: The case to classify.
+        :param modify_case: Whether to modify the original case attributes with the conclusion or not.
         :return: The category that the case belongs to.
         """
         pass
@@ -124,7 +123,10 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         if case_query is None:
             raise ValueError("The case query cannot be None.")
         if case_query.target is None:
-            expert.ask_for_conclusion(case_query)
+            case_query_cp = copy(case_query)
+            self.classify(case_query_cp.case, modify_case=True)
+            expert.ask_for_conclusion(case_query_cp)
+            case_query.target = case_query_cp.target
             if case_query.target is None:
                 return self.classify(case_query.case)
 
@@ -169,24 +171,62 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                 self.fig = plt.figure(0)
             draw_tree(self.start_rule, self.fig)
 
-    @staticmethod
-    def case_has_conclusion(case: Union[Case, SQLTable], conclusion_name: str) -> bool:
-        """
-        Check if the case has a conclusion.
+    @property
+    def type_(self):
+        return self.__class__
+
+    @property
+    def generated_python_file_name(self) -> str:
+        if self._generated_python_file_name is None:
+            self._generated_python_file_name = self._default_generated_python_file_name
+        return self._generated_python_file_name
 
-        :param case: The case to check.
-        :param conclusion_name: The target category name to compare the case with.
-        :return: Whether the case has a conclusion or not.
+    @generated_python_file_name.setter
+    def generated_python_file_name(self, value: str):
         """
-        return hasattr(case, conclusion_name) and getattr(case, conclusion_name) is not None
+        Set the generated python file name.
+        :param value: The new value for the generated python file name.
+        """
+        self._generated_python_file_name = value
 
     @property
-    def type_(self):
-        return self.__class__
+    @abstractmethod
+    def _default_generated_python_file_name(self) -> str:
+        """
+        :return: The default generated python file name.
+        """
+        pass
+
+    @abstractmethod
+    def update_from_python_file(self, package_dir: str):
+        """
+        Update the rules from the generated python file, that might have been modified by the user.
+
+        :param package_dir: The directory of the package that contains the generated python file.
+        """
+        pass
 
 
 class RDRWithCodeWriter(RippleDownRules, ABC):
 
+    def update_from_python_file(self, package_dir: str):
+        """
+        Update the rules from the generated python file, that might have been modified by the user.
+
+        :param package_dir: The directory of the package that contains the generated python file.
+        """
+        rule_ids = [r.uid for r in [self.start_rule] + list(self.start_rule.descendants) if r.conditions is not None]
+        condition_func_names = [f'conditions_{rid}' for rid in rule_ids]
+        conclusion_func_names = [f'conclusion_{rid}' for rid in rule_ids]
+        all_func_names = condition_func_names + conclusion_func_names
+        filepath = f"{package_dir}/{self.generated_python_defs_file_name}.py"
+        functions_source = extract_function_source(filepath, all_func_names, include_signature=False)
+        for rule in [self.start_rule] + list(self.start_rule.descendants):
+            if rule.conditions is not None:
+                rule.conditions.user_input = functions_source[f"conditions_{rule.uid}"]
+            if rule.conclusion is not None:
+                rule.conclusion.user_input = functions_source[f"conclusion_{rule.uid}"]
+
     @abstractmethod
     def write_rules_as_source_code_to_file(self, rule: Rule, file, parent_indent: str = "",
                                            defs_file: Optional[str] = None):
@@ -238,31 +278,26 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         :return: The imports for the generated python file of the RDR as a string.
         """
-        defs_imports = ""
+        defs_imports_list = []
         for rule in [self.start_rule] + list(self.start_rule.descendants):
             if not rule.conditions:
                 continue
             for scope in [rule.conditions.scope, rule.conclusion.scope]:
                 if scope is None:
                     continue
-                for k, v in scope.items():
-                    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 defs_imports:
-                        continue
-                    defs_imports += new_imports
-        imports = ""
+                defs_imports_list.extend(get_imports_from_scope(scope))
+        if self.case_type.__module__ != "builtins":
+            defs_imports_list.append(f"from {self.case_type.__module__} import {self.case_type.__name__}")
+        defs_imports = "\n".join(set(defs_imports_list)) + "\n"
+        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
+            imports.append(f"from {self.case_type.__module__} import {self.case_type.__name__}")
         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"
+                imports.append(f"from {conclusion_type.__module__} import {conclusion_type.__name__}")
+        imports.append("from ripple_down_rules.datastructures.case import Case, create_case")
+        imports = set(imports).difference(defs_imports_list)
+        imports = "\n".join(imports) + "\n"
         return imports, defs_imports
 
     def get_rdr_classifier_from_python_file(self, package_name: str) -> Callable[[Any], Any]:
@@ -279,20 +314,6 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             pass
         return importlib.import_module(name).classify
 
-    @property
-    def generated_python_file_name(self) -> str:
-        if self._generated_python_file_name is None:
-            self._generated_python_file_name = self._default_generated_python_file_name
-        return self._generated_python_file_name
-
-    @generated_python_file_name.setter
-    def generated_python_file_name(self, value: str):
-        """
-        Set the generated python file name.
-        :param value: The new value for the generated python file name.
-        """
-        self._generated_python_file_name = value
-
     @property
     def _default_generated_python_file_name(self) -> str:
         """
@@ -390,12 +411,12 @@ class SingleClassRDR(RDRWithCodeWriter):
             self.start_rule = SingleClassRule(case_query.conditions, case_query.target, corner_case=case_query.case,
                                               conclusion_name=case_query.attribute_name)
 
-    def classify(self, case: Case, modify_original_case: bool = False) -> Optional[Any]:
+    def classify(self, case: Case, modify_case: bool = False) -> Optional[Any]:
         """
         Classify a case by recursively evaluating the rules until a rule fires or the last rule is reached.
 
         :param case: The case to classify.
-        :param modify_original_case: Whether to modify the original case attributes with the conclusion or not.
+        :param modify_case: Whether to modify the original case attributes with the conclusion or not.
         """
         pred = self.evaluate(case)
         return pred.conclusion(case) if pred is not None and pred.fired else self.default_conclusion
@@ -481,7 +502,7 @@ class MultiClassRDR(RDRWithCodeWriter):
         super(MultiClassRDR, self).__init__(start_rule)
         self.mode: MCRDRMode = mode
 
-    def classify(self, case: Union[Case, SQLTable]) -> Set[Any]:
+    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False) -> Set[Any]:
         evaluated_rule = self.start_rule
         self.conclusions = []
         while evaluated_rule:
@@ -492,7 +513,7 @@ class MultiClassRDR(RDRWithCodeWriter):
         return make_set(self.conclusions)
 
     def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None
-                 , **kwargs) -> Set[Union[CaseAttribute, CallableExpression, None]]:
+                  , **kwargs) -> Set[Union[CaseAttribute, CallableExpression, None]]:
         """
         Classify a case, and ask the user for stopping rules or classifying rules if the classification is incorrect
          or missing by comparing the case with the target category if provided.
@@ -504,13 +525,13 @@ class MultiClassRDR(RDRWithCodeWriter):
         self.conclusions = []
         self.stop_rule_conditions = None
         evaluated_rule = self.start_rule
-        target = make_set(case_query.target_value)
+        target_value = make_set(case_query.target_value)
         while evaluated_rule:
             next_rule = evaluated_rule(case_query.case)
             rule_conclusion = evaluated_rule.conclusion(case_query.case)
 
             if evaluated_rule.fired:
-                if not make_set(rule_conclusion).issubset(target):
+                if not make_set(rule_conclusion).issubset(target_value):
                     # Rule fired and conclusion is different from target
                     self.stop_wrong_conclusion_else_add_it(case_query, expert, evaluated_rule)
                 else:
@@ -518,7 +539,7 @@ class MultiClassRDR(RDRWithCodeWriter):
                     self.add_conclusion(evaluated_rule, case_query.case)
 
             if not next_rule:
-                if not make_set(target).issubset(make_set(self.conclusions)):
+                if not make_set(target_value).issubset(make_set(self.conclusions)):
                     # Nothing fired and there is a target that should have been in the conclusions
                     self.add_rule_for_case(case_query, expert)
                     # Have to check all rules again to make sure only this new rule fires
@@ -556,12 +577,9 @@ class MultiClassRDR(RDRWithCodeWriter):
 
     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 += f"from typing_extensions import Set, Union\n"
         imports += "from ripple_down_rules.utils import make_set\n"
+        defs_imports += "from typing_extensions import Union\n"
         return imports, defs_imports
 
     def update_start_rule(self, case_query: CaseQuery, expert: Expert):
@@ -594,6 +612,8 @@ class MultiClassRDR(RDRWithCodeWriter):
         rule_conclusion = evaluated_rule.conclusion(case_query.case)
         if is_conflicting(rule_conclusion, case_query.target_value):
             self.stop_conclusion(case_query, expert, evaluated_rule)
+        else:
+            self.add_conclusion(evaluated_rule, case_query.case)
 
     def stop_conclusion(self, case_query: CaseQuery,
                         expert: Expert, evaluated_rule: MultiClassTopRule):
@@ -829,6 +849,15 @@ class GeneralRDR(RippleDownRules):
             start_rules_dict[k] = get_type_from_string(v['_type']).from_json(v)
         return cls(start_rules_dict)
 
+    def update_from_python_file(self, package_dir: str) -> None:
+        """
+        Update the rules from the generated python file, that might have been modified by the user.
+
+        :param package_dir: The directory of the package that contains the generated python file.
+        """
+        for rdr in self.start_rules_dict.values():
+            rdr.update_from_python_file(package_dir)
+
     def write_to_python_file(self, file_path: str, postfix: str = "") -> None:
         """
         Write the tree of rules as source code to a file.
@@ -864,21 +893,10 @@ class GeneralRDR(RippleDownRules):
     def get_rdr_classifier_from_python_file(self, file_path: str) -> Callable[[Any], Any]:
         """
         :param file_path: The path to the file that contains the RDR classifier function.
-        :param postfix: The postfix to add to the file name.
         :return: The module that contains the rdr classifier function.
         """
         return importlib.import_module(f"{file_path.strip('./')}.{self.generated_python_file_name}").classify
 
-    @property
-    def generated_python_file_name(self) -> str:
-        if self._generated_python_file_name is None:
-            self._generated_python_file_name = self._default_generated_python_file_name
-        return self._generated_python_file_name
-
-    @generated_python_file_name.setter
-    def generated_python_file_name(self, value: str):
-        self._generated_python_file_name = value
-
     @property
     def _default_generated_python_file_name(self) -> str:
         """

ripple_down_rules/rules.py

@@ -2,17 +2,16 @@ from __future__ import annotations
 
 import re
 from abc import ABC, abstractmethod
-from enum import Enum
+from uuid import uuid4
 
 from anytree import NodeMixin
+from sqlalchemy.orm import DeclarativeBase as SQLTable
 from typing_extensions import List, Optional, Self, Union, Dict, Any, Tuple
 
 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, conclusion_to_json, \
-    get_rule_conclusion_as_source_code
+from .utils import SubclassJSONSerializer, conclusion_to_json
 
 
 class Rule(NodeMixin, SubclassJSONSerializer, ABC):
@@ -26,7 +25,8 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
                  parent: Optional[Rule] = None,
                  corner_case: Optional[Union[Case, SQLTable]] = None,
                  weight: Optional[str] = None,
-                 conclusion_name: Optional[str] = None):
+                 conclusion_name: Optional[str] = None,
+                 uid: Optional[str] = None):
         """
         A rule in the ripple down rules classifier.
 
@@ -36,6 +36,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         :param corner_case: The corner case that this rule is based on/created from.
         :param weight: The weight of the rule, which is the type of edge connecting the rule to its parent.
         :param conclusion_name: The name of the conclusion of the rule.
+        :param uid: The unique id of the rule.
         """
         super(Rule, self).__init__()
         self.conclusion = conclusion
@@ -46,6 +47,8 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         self.conclusion_name: Optional[str] = conclusion_name
         self.json_serialization: Optional[Dict[str, Any]] = None
         self._name: Optional[str] = None
+        # generate a unique id for the rule using uuid4
+        self.uid: str = uid if uid else str(uuid4().int)
 
     def _post_detach(self, parent):
         """
@@ -90,15 +93,32 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             conclusion = self.conclusion.user_input
         else:
             conclusion = self.conclusion.conclusion
-        conclusion_func, conclusion_func_call = self._conclusion_source_code(conclusion, parent_indent=parent_indent)
+        conclusion_func, conclusion_func_call = self.get_conclusion_as_source_code(conclusion,
+                                                                                   parent_indent=parent_indent)
         if conclusion_func is not None:
             with open(defs_file, 'a') as f:
                 f.write(conclusion_func.strip() + "\n\n\n")
         return conclusion_func_call
 
-    @abstractmethod
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[Optional[str], str]:
-        pass
+    def get_conclusion_as_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[Optional[str], str]:
+        """
+        Convert the conclusion of a rule to source code.
+
+        :param conclusion: The conclusion to convert to source code.
+        :param parent_indent: The indentation of the parent rule.
+        :return: The source code of the conclusion as a tuple of strings, one for the function and one for the call.
+        """
+        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_{self.uid}"
+            conclusion_lines[0] = re.sub(r"def (\w+)", new_function_name, conclusion_lines[0])
+            func_call = f"{parent_indent}    return {new_function_name.replace('def ', '')}(case)\n"
+            return "\n".join(conclusion_lines).strip(' '), func_call
+        else:
+            raise ValueError(f"Conclusion is format is not valid, it should be contain a function definition."
+                             f" Instead got:\n{conclusion}\n")
 
     def write_condition_as_source_code(self, parent_indent: str = "", defs_file: Optional[str] = None) -> str:
         """
@@ -116,7 +136,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             # 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)}"
+            new_function_name = f"def conditions_{self.uid}"
             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:
@@ -133,7 +153,8 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
                               "parent": self.parent.json_serialization if self.parent else None,
                               "corner_case": SubclassJSONSerializer.to_json_static(self.corner_case),
                               "conclusion_name": self.conclusion_name,
-                              "weight": self.weight}
+                              "weight": self.weight,
+                              "uid": self.uid}
         return json_serialization
 
     @classmethod
@@ -143,7 +164,8 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
                           parent=cls.from_json(data["parent"]),
                           corner_case=Case.from_json(data["corner_case"]),
                           conclusion_name=data["conclusion_name"],
-                          weight=data["weight"])
+                          weight=data["weight"],
+                          uid=data["uid"])
         return loaded_rule
 
     @property
@@ -268,14 +290,6 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
         loaded_rule.alternative = SingleClassRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[Optional[str], str]:
-        conclusion = str(conclusion)
-        # indent = parent_indent + " " * 4
-        # if '\n' not in conclusion:
-        #     return None, 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"
 
@@ -319,7 +333,7 @@ class MultiClassStopRule(Rule, HasAlternativeRule):
         loaded_rule.alternative = MultiClassStopRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[None, str]:
+    def get_conclusion_as_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[None, str]:
         return None, f"{parent_indent}{' ' * 4}pass\n"
 
     def _if_statement_source_code_clause(self) -> str:
@@ -364,20 +378,11 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
         loaded_rule.alternative = MultiClassTopRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[str, str]:
-        conclusion_str = str(conclusion)
-        indent = parent_indent + " " * 4
-        # if '\n' not in conclusion_str:
-        #     func = None
-        #     if is_iterable(conclusion):
-        #         conclusion_str = "{" + ", ".join([str(c) for c in conclusion]) + "}"
-        #     else:
-        #         conclusion_str = "{" + str(conclusion) + "}"
-        # else:
-        func, func_call = get_rule_conclusion_as_source_code(self, conclusion_str, parent_indent=parent_indent)
+    def get_conclusion_as_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[str, str]:
+        func, func_call = super().get_conclusion_as_source_code(str(conclusion), parent_indent=parent_indent)
         conclusion_str = func_call.replace("return ", "").strip()
 
-        statement = f"{indent}conclusions.update(make_set({conclusion_str}))\n"
+        statement = f"{parent_indent}    conclusions.update(make_set({conclusion_str}))\n"
         if self.alternative is None:
             statement += f"{parent_indent}return conclusions\n"
         return func, statement

ripple_down_rules/utils.py

@@ -36,16 +36,131 @@ import ast
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
-def encapsulate_user_input(user_input: str, func_signature: str) -> str:
+def get_imports_from_types(types: List[Type]) -> List[str]:
+    """
+    Get the import statements for a list of types.
+
+    :param types: The types to get the import statements for.
+    :return: The import statements as a string.
+    """
+    imports = map(get_import_from_type, types)
+    return list({i for i in imports if i is not None})
+
+
+def get_import_from_type(type_: Type) -> Optional[str]:
+    """
+    Get the import statement for a given type.
+
+    :param type_: The type to get the import statement for.
+    :return: The import statement as a string.
+    """
+    if hasattr(type_, "__module__") and hasattr(type_, "__name__"):
+        if type_.__module__ == "builtins":
+            return
+        return f"from {type_.__module__} import {type_.__name__}"
+
+
+def get_imports_from_scope(scope: Dict[str, Any]) -> List[str]:
+    """
+    Get the imports from the given scope.
+
+    :param scope: The scope to get the imports from.
+    :return: The imports as a string.
+    """
+    imports = []
+    for k, v in scope.items():
+        if not hasattr(v, "__module__") or not hasattr(v, "__name__"):
+            continue
+        imports.append(f"from {v.__module__} import {v.__name__}")
+    return imports
+
+
+def extract_imports(file_path):
+    with open(file_path, "r") as f:
+        tree = ast.parse(f.read(), filename=file_path)
+
+    scope = {}
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                module_name = alias.name
+                asname = alias.asname or alias.name
+                try:
+                    scope[asname] = importlib.import_module(module_name)
+                except ImportError as e:
+                    print(f"Could not import {module_name}: {e}")
+        elif isinstance(node, ast.ImportFrom):
+            module_name = node.module
+            for alias in node.names:
+                name = alias.name
+                asname = alias.asname or name
+                try:
+                    module = importlib.import_module(module_name)
+                    scope[asname] = getattr(module, name)
+                except (ImportError, AttributeError) as e:
+                    print(f"Could not import {name} from {module_name}: {e}")
+
+    return scope
+
+
+def extract_function_source(file_path: str,
+                            function_names: List[str], join_lines: bool = True,
+                            return_line_numbers: bool = False,
+                            include_signature: bool = True) \
+        -> Union[Dict[str, Union[str, List[str]]],
+        Tuple[Dict[str, Union[str, List[str]]], List[Tuple[int, int]]]]:
+    """
+    Extract the source code of a function from a file.
+
+    :param file_path: The path to the file.
+    :param function_names: The names of the functions to extract.
+    :param join_lines: Whether to join the lines of the function.
+    :param return_line_numbers: Whether to return the line numbers of the function.
+    :param include_signature: Whether to include the function signature in the source code.
+    :return: A dictionary mapping function names to their source code as a string if join_lines is True,
+     otherwise as a list of strings.
+    """
+    with open(file_path, "r") as f:
+        source = f.read()
+
+    # Parse the source code into an AST
+    tree = ast.parse(source)
+    function_names = make_list(function_names)
+    functions_source: Dict[str, Union[str, List[str]]] = {}
+    line_numbers = []
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef) and node.name in function_names:
+            # Get the line numbers of the function
+            lines = source.splitlines()
+            func_lines = lines[node.lineno - 1:node.end_lineno]
+            if not include_signature:
+                func_lines = func_lines[1:]
+            line_numbers.append((node.lineno, node.end_lineno))
+            functions_source[node.name] = "\n".join(func_lines) if join_lines else func_lines
+            if len(functions_source) == len(function_names):
+                break
+    if len(functions_source) != len(function_names):
+        raise ValueError(f"Could not find all functions in {file_path}: {function_names} not found,"
+                         f"functions not found: {set(function_names) - set(functions_source.keys())}")
+    if return_line_numbers:
+        return functions_source, line_numbers
+    return functions_source
+
+
+def encapsulate_user_input(user_input: str, func_signature: str, func_doc: Optional[str] = None) -> str:
     """
     Encapsulate the user input string with a function definition.
 
     :param user_input: The user input string.
     :param func_signature: The function signature to use for encapsulation.
+    :param func_doc: The function docstring to use for encapsulation.
     :return: The encapsulated user input string.
     """
     if func_signature not in user_input:
         new_user_input = func_signature + "\n    "
+        if func_doc is not None:
+            new_user_input += f"\"\"\"{func_doc}\"\"\"" + "\n    "
         if "return " not in user_input:
             if '\n' not in user_input:
                 new_user_input += f"return {user_input}"
@@ -173,29 +288,6 @@ def calculate_precision_and_recall(pred_cat: Dict[str, Any], target: Dict[str, A
     return precision, recall
 
 
-def get_rule_conclusion_as_source_code(rule: Rule, conclusion: str, parent_indent: str = "") -> Tuple[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 as a tuple of strings, one for the function and one for the call.
-    """
-    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])
-        func_call = f"{indent}return {new_function_name.replace('def ', '')}(case)\n"
-        return "\n".join(conclusion_lines).strip(' '), func_call
-    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={
@@ -317,7 +409,13 @@ def extract_dependencies(code_lines):
 
     for stmt in reversed(tree.body[:-1]):
         if handle_stmt(stmt, needed):
-            required_lines.insert(0, code_lines[line_map[id(stmt)]])
+            # check if the statement is a function, if so then all its lines not just the line in line_map are needed.
+            if isinstance(stmt, ast.FunctionDef):
+                start_code_line = line_map[id(stmt)]
+                end_code_line = start_code_line + stmt.end_lineno
+                required_lines.extend(code_lines[start_code_line:end_code_line])
+            else:
+                required_lines.insert(0, code_lines[line_map[id(stmt)]])
 
     required_lines.append(code_lines[-1])  # Always include return
     return required_lines
@@ -749,9 +847,12 @@ def copy_orm_instance(instance: SQLTable) -> SQLTable:
     :return: The copied instance.
     """
     session: Session = inspect(instance).session
-    session.expunge(instance)
-    new_instance = deepcopy(instance)
-    session.add(instance)
+    if session is not None:
+        session.expunge(instance)
+        new_instance = deepcopy(instance)
+        session.add(instance)
+    else:
+        new_instance = instance
     return new_instance
 
 

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

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

@@ -0,0 +1,20 @@
+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=sab5yqSJaMGgqfOsXybzZhbKx2vyU0h5dfcSqsQuY7E,16118
+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=Q5VWgisHCFxEA06Y0ImSfu7cozVJCHTCDYGWbDJNlgA,43516
+ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
+ripple_down_rules/datastructures/callable_expression.py,sha256=1hwRjS8-csfZ0HSlhLLOBCcvKJ8W3_N1qHayFLNhl3k,10908
+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=hlE6LAa1jUafnG_6UazvaPDfhC1ClI7hKvD89zOyAO8,4661
+ripple_down_rules-0.2.0.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.2.0.dist-info/METADATA,sha256=FZV_PqD3Yc6Qw1YCPAZowkycnAa6OzdcyMlpT7w8AS4,42575
+ripple_down_rules-0.2.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+ripple_down_rules-0.2.0.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.2.0.dist-info/RECORD,,

{ripple_down_rules-0.1.69.dist-info → ripple_down_rules-0.2.0.dist-info}/WHEEL

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

ripple_down_rules-0.1.69.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=gdLV2qhq-1kbmlJhVmkCwGGFhIeDxV0p5u2hwrbGUpk,6370
-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=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=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.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,,