ripple-down-rules 0.6.28__py3-none-any.whl → 0.6.30__py3-none-any.whl

ripple_down_rules/user_interface/prompt.py

@@ -1,7 +1,10 @@
 import ast
 import logging
+import sys
 from _ast import AST
 
+from .. import logger
+
 try:
     from PyQt6.QtWidgets import QApplication
     from .gui import RDRCaseViewer, style
@@ -29,7 +32,7 @@ class UserPrompt:
     """
     shell_lock: RLock = RLock()  # To ensure that only one thread can access the shell at a time
 
-    def __init__(self):
+    def __init__(self, prompt_user: bool = True):
         """
         Initialize the UserPrompt class.
         """
@@ -51,18 +54,19 @@ class UserPrompt:
         callable_expression: Optional[CallableExpression] = None
         while True:
             with self.shell_lock:
-                user_input, expression_tree = self.prompt_user_about_case(case_query, prompt_for, prompt_str, code_to_modify=prev_user_input)
+                user_input, expression_tree = self.prompt_user_about_case(case_query, prompt_for, prompt_str,
+                                                                          code_to_modify=prev_user_input)
             if user_input is None:
                 if prompt_for == PromptFor.Conclusion:
-                    self.print_func(f"{Fore.YELLOW}No conclusion provided. Exiting.{Style.RESET_ALL}")
+                    self.print_func(f"\n{Fore.YELLOW}No conclusion provided. Exiting.{Style.RESET_ALL}")
                     return None, None
                 else:
-                    self.print_func(f"{Fore.RED}Conditions must be provided. Please try again.{Style.RESET_ALL}")
+                    self.print_func(f"\n{Fore.RED}Conditions must be provided. Please try again.{Style.RESET_ALL}")
                     continue
-            elif user_input == "exit":
-                self.print_func(f"{Fore.YELLOW}Exiting.{Style.RESET_ALL}")
+            elif user_input in ["exit", 'quit']:
+                self.print_func(f"\n{Fore.YELLOW}Exiting.{Style.RESET_ALL}")
                 return user_input, None
-                
+
             prev_user_input = '\n'.join(user_input.split('\n')[2:-1])
             conclusion_type = bool if prompt_for == PromptFor.Conditions else case_query.attribute_type
             callable_expression = CallableExpression(user_input, conclusion_type, expression_tree=expression_tree,
@@ -73,8 +77,9 @@ class UserPrompt:
                 if len(make_list(result)) == 0 and (user_input_to_modify is not None
                                                     and (prev_user_input != user_input_to_modify)):
                     user_input_to_modify = prev_user_input
-                    self.print_func(f"{Fore.YELLOW}The given expression gave an empty result for case {case_query.name}."
-                          f" Please accept or modify!{Style.RESET_ALL}")
+                    self.print_func(
+                        f"{Fore.YELLOW}The given expression gave an empty result for case {case_query.name}."
+                        f" Please accept or modify!{Style.RESET_ALL}")
                     continue
                 break
             except Exception as e:
@@ -82,7 +87,6 @@ class UserPrompt:
                 self.print_func(f"{Fore.RED}{e}{Style.RESET_ALL}")
         return user_input, callable_expression
 
-
     def prompt_user_about_case(self, case_query: CaseQuery, prompt_for: PromptFor,
                                prompt_str: Optional[str] = None,
                                code_to_modify: Optional[str] = None) -> Tuple[Optional[str], Optional[AST]]:
@@ -95,7 +99,7 @@ class UserPrompt:
         :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.
         """
-        self.print_func("Entered shell")
+        logger.debug("Entered shell")
         initial_prompt_str = f"{prompt_str}\n" if prompt_str is not None else ''
         if prompt_for == PromptFor.Conclusion:
             prompt_for_str = f"Give possible value(s) for:"
@@ -103,20 +107,32 @@ class UserPrompt:
             prompt_for_str = f"Give conditions for:"
         case_query.scope.update({'case': case_query.case})
         shell = None
+
         if self.viewer is None:
+            prompt_for_str = prompt_for_str.replace(":", f" {case_query.name}:")
             prompt_str = f"{Fore.WHITE}{initial_prompt_str}{Fore.MAGENTA}{prompt_for_str}"
             prompt_str = self.construct_prompt_str_for_shell(case_query, prompt_for, prompt_str)
             shell = IPythonShell(header=prompt_str, prompt_for=prompt_for, case_query=case_query,
-                                    code_to_modify=code_to_modify)
+                                 code_to_modify=code_to_modify)
         else:
-            prompt_str = initial_prompt_str + prompt_for_str
-            self.viewer.update_for_case_query(case_query, prompt_str,
-                                                prompt_for=prompt_for, code_to_modify=code_to_modify)
+            prompt_str = case_query.current_value_str
+            self.viewer.update_for_case_query(case_query, prompt_for=prompt_for, code_to_modify=code_to_modify,
+                                              title=prompt_for_str, prompt_str=prompt_str)
         user_input, expression_tree = self.prompt_user_input_and_parse_to_expression(shell=shell)
-        self.print_func("Exited shell")
+        logger.debug("Exited shell")
         return user_input, expression_tree
 
-
+    def build_prompt_str_for_ai(self, case_query: CaseQuery, prompt_for: PromptFor,
+                                initial_prompt_str: Optional[str] = None) -> str:
+        initial_prompt_str = f"{initial_prompt_str}\n" if initial_prompt_str is not None else ''
+        if prompt_for == PromptFor.Conclusion:
+            prompt_for_str = f"Give possible value(s) for:"
+        else:
+            prompt_for_str = f"Give conditions for:"
+        prompt_for_str = prompt_for_str.replace(":", f" {case_query.name}:")
+        prompt_str = f"{Fore.WHITE}{initial_prompt_str}{Fore.MAGENTA}{prompt_for_str}"
+        prompt_str += '\n' + case_query.current_value_str
+        return prompt_str
 
     def construct_prompt_str_for_shell(self, case_query: CaseQuery, prompt_for: PromptFor,
                                        prompt_str: Optional[str] = None) -> str:
@@ -127,8 +143,7 @@ class UserPrompt:
         :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.
         """
-        prompt_str += (f"\n{Fore.CYAN}{case_query.name}{Fore.MAGENTA} of type(s) "
-                       f"{Fore.CYAN}({', '.join(map(lambda x: x.__name__, case_query.core_attribute_type))}){Fore.MAGENTA}")
+        prompt_str += '\n' + case_query.current_value_str
         if prompt_for == PromptFor.Conditions:
             prompt_str += (f"\ne.g. `{Fore.GREEN}return {Fore.BLUE}len{Fore.RESET}(case.attribute) > {Fore.BLUE}0` "
                            f"{Fore.MAGENTA}\nOR `{Fore.GREEN}return {Fore.YELLOW}True`{Fore.MAGENTA} (If you want the"
@@ -138,7 +153,6 @@ class UserPrompt:
         prompt_str = f"{Fore.MAGENTA}{prompt_str}{Fore.YELLOW}\n(Write %help for guide){Fore.RESET}\n"
         return prompt_str
 
-
     def prompt_user_input_and_parse_to_expression(self, shell: Optional[IPythonShell] = None,
                                                   user_input: Optional[str] = None) \
             -> Tuple[Optional[str], Optional[ast.AST]]:
@@ -152,17 +166,18 @@ class UserPrompt:
         while True:
             if user_input is None:
                 user_input = self.start_shell_and_get_user_input(shell=shell)
-                if user_input is None or user_input == 'exit':
+                if user_input is None or user_input in ['exit', 'quit']:
                     return user_input, None
-                self.print_func(f"{Fore.GREEN}Captured User input: {Style.RESET_ALL}")
-                highlighted_code = highlight(user_input, PythonLexer(), TerminalFormatter())
-                self.print_func(highlighted_code)
+                if logger.level <= logging.DEBUG:
+                    self.print_func(f"\n{Fore.GREEN}Captured User input: {Style.RESET_ALL}")
+                    highlighted_code = highlight(user_input, PythonLexer(), TerminalFormatter())
+                    self.print_func(highlighted_code)
             try:
                 return user_input, parse_string_to_expression(user_input)
             except Exception as e:
                 msg = f"Error parsing expression: {e}"
                 logging.error(msg)
-                self.print_func(f"{Fore.RED}{msg}{Style.RESET_ALL}")
+                self.print_func(f"\n{Fore.RED}{msg}{Style.RESET_ALL}")
                 user_input = None
 
     def start_shell_and_get_user_input(self, shell: Optional[IPythonShell] = None) -> Optional[str]:
@@ -185,6 +200,6 @@ class UserPrompt:
             self.viewer.show()
             app.exec()
             if self.viewer.exit_status == ExitStatus.CLOSE:
-                exit(0)
+                sys.exit()
             user_input = self.viewer.user_input
         return user_input

ripple_down_rules/user_interface/template_file_creator.py

@@ -109,20 +109,21 @@ class TemplateFileCreator:
 
         self.open_file_in_editor()
 
-    def open_file_in_editor(self):
+    def open_file_in_editor(self, file_path: Optional[str] = None):
         """
         Open the file in the available editor.
         """
+        file_path = file_path or self.temp_file_path
         if self.editor_cmd is not None:
-            subprocess.Popen([self.editor_cmd, self.temp_file_path],
+            subprocess.Popen([self.editor_cmd, file_path],
                              stdout=subprocess.DEVNULL,
                              stderr=subprocess.DEVNULL)
         elif self.editor == Editor.Pycharm:
-            subprocess.Popen(["pycharm", "--line", str(self.user_edit_line), self.temp_file_path],
+            subprocess.Popen(["pycharm", "--line", str(self.user_edit_line), file_path],
                              stdout=subprocess.DEVNULL,
                              stderr=subprocess.DEVNULL)
         elif self.editor == Editor.Code:
-            subprocess.Popen(["code", self.temp_file_path])
+            subprocess.Popen(["code", file_path])
         elif self.editor == Editor.CodeServer:
             try:
                 subprocess.check_output(["pgrep", "-f", "code-server"])
@@ -134,7 +135,8 @@ class TemplateFileCreator:
             except (subprocess.CalledProcessError, ValueError) as e:
                 self.process = start_code_server(self.workspace)
             self.print_func(f"Open code-server in your browser at http://localhost:{self.port}?folder={self.workspace}")
-        self.print_func(f"Edit the file: {Fore.MAGENTA}{self.temp_file_path}")
+        if file_path.endswith('.py'):
+            self.print_func(f"Edit the file: {Fore.MAGENTA}{file_path}")
 
     def build_boilerplate_code(self):
         imports = self.get_imports()
@@ -183,7 +185,7 @@ class TemplateFileCreator:
             func_args = ', '.join([f"{k}: {v}" if str(v) not in ["NoneType", "None"] else str(k)
                                    for k, v in func_args.items()])
         else:
-            func_args = f"case: {self.case_type.__name__}"
+            func_args = f"case: {self.case_query.case_type.__name__}"
         return func_args
 
     def write_to_file(self, code: str):
@@ -212,7 +214,7 @@ class TemplateFileCreator:
                 else:
                     case_type_imports.append(v)
         else:
-            case_type_imports.append(self.case_type)
+            case_type_imports.append(self.case_query.case_type)
         if self.output_type is None:
             output_type_imports = [Any]
         else:
@@ -302,7 +304,7 @@ class TemplateFileCreator:
                 exec(source, scope, exec_globals)
                 user_function = exec_globals[func_name]
                 updates[func_name] = user_function
-                print_func(f"{Fore.BLUE}Loaded `{func_name}` function into user namespace.{Style.RESET_ALL}")
+                print_func(f"\n{Fore.WHITE}Loaded the following function into user namespace:\n{Fore.GREEN}{func_name}{Style.RESET_ALL}")
                 break
         if updates:
             all_code_lines = extract_function_source(file_path,

ripple_down_rules/utils.py

@@ -21,8 +21,10 @@ from subprocess import check_call
 from tempfile import NamedTemporaryFile
 from textwrap import dedent
 from types import NoneType
+import inspect
 
 import six
+from graphviz import Source
 from sqlalchemy.exc import NoInspectionAvailable
 from . import logger
 
@@ -45,7 +47,7 @@ except ImportError as e:
 
 import requests
 from anytree import Node, RenderTree, PreOrderIter
-from sqlalchemy import MetaData, inspect
+from sqlalchemy import MetaData, inspect as sql_inspect
 from sqlalchemy.orm import Mapped, registry, class_mapper, DeclarativeBase as SQLTable, Session
 from tabulate import tabulate
 from typing_extensions import Callable, Set, Any, Type, Dict, TYPE_CHECKING, get_type_hints, \
@@ -146,7 +148,9 @@ def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = N
 def extract_function_source(file_path: str,
                             function_names: List[str], join_lines: bool = True,
                             return_line_numbers: bool = False,
-                            include_signature: bool = True) \
+                            include_signature: bool = True,
+                            as_list: bool = False,
+                            is_class: bool = False) \
         -> Union[Dict[str, Union[str, List[str]]],
         Tuple[Dict[str, Union[str, List[str]]], Dict[str, Tuple[int, int]]]]:
     """
@@ -157,6 +161,9 @@ def extract_function_source(file_path: str,
     :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.
+    :param as_list: Whether to return a list of function sources instead of dict (useful when there is multiple
+     functions with same name).
+    :param is_class: Whether to also look for class definitions
     :return: A dictionary mapping function names to their source code as a string if join_lines is True,
      otherwise as a list of strings.
     """
@@ -167,24 +174,39 @@ def extract_function_source(file_path: str,
     tree = ast.parse(source)
     function_names = make_list(function_names)
     functions_source: Dict[str, Union[str, List[str]]] = {}
+    functions_source_list: List[Union[str, List[str]]] = []
     line_numbers: Dict[str, Tuple[int, int]] = {}
+    line_numbers_list: List[Tuple[int, int]] = []
+    if is_class:
+        look_for_type = ast.ClassDef
+    else:
+        look_for_type = ast.FunctionDef
+
     for node in tree.body:
-        if isinstance(node, ast.FunctionDef) and (node.name in function_names or len(function_names) == 0):
+        if isinstance(node, look_for_type) and (node.name in function_names or len(function_names) == 0):
             # 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[node.name] = (node.lineno, node.end_lineno)
-            functions_source[node.name] = dedent("\n".join(func_lines)) if join_lines else func_lines
-            if (len(functions_source) >= len(function_names)) and (not len(function_names) == 0):
-                break
-    if len(functions_source) < len(function_names):
+            if as_list:
+                line_numbers_list.append((node.lineno, node.end_lineno))
+            else:
+                line_numbers[node.name] = (node.lineno, node.end_lineno)
+            parsed_function = dedent("\n".join(func_lines)) if join_lines else func_lines
+            if as_list:
+                functions_source_list.append(parsed_function)
+            else:
+                functions_source[node.name] = parsed_function
+            if len(function_names) > 0:
+                if len(functions_source) >= len(function_names) or len(functions_source_list) >= len(function_names):
+                    break
+    if len(functions_source) < len(function_names) and len(functions_source_list) < len(function_names):
         logger.warning(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
+        return functions_source if not as_list else functions_source_list, line_numbers if not as_list else line_numbers_list
+    return functions_source if not as_list else functions_source_list
 
 
 def encapsulate_user_input(user_input: str, func_signature: str, func_doc: Optional[str] = None) -> str:
@@ -791,6 +813,13 @@ def get_import_path_from_path(path: str) -> Optional[str]:
     return package_name
 
 
+def get_class_file_path(cls):
+    """
+    Get the file path of a class.
+    """
+    return os.path.abspath(inspect.getfile(cls))
+
+
 def get_function_import_data(func: Callable) -> Tuple[str, str]:
     """
     Get the import path of a function.
@@ -1281,7 +1310,7 @@ def copy_orm_instance(instance: SQLTable) -> SQLTable:
     :return: The copied instance.
     """
     try:
-        session: Session = inspect(instance).session
+        session: Session = sql_inspect(instance).session
     except NoInspectionAvailable:
         session = None
     if session is not None:
@@ -1833,6 +1862,24 @@ class FilteredDotExporter(object):
             yield node
         for edge in self.__iter_edges(indent, nodenamefunc, edgeattrfunc, edgetypefunc):
             yield edge
+        legend_dot_graph = """
+// Color legend as a subgraph
+subgraph cluster_legend {
+    label = "Legend";
+    style = dashed;
+    color = gray;
+
+    legend_green [label="Fired->Query Related Value", shape=box, style=filled, fillcolor=green, fontcolor=black, size=0.5];
+    legend_yellow [label="Fired->Some Value", shape=box, style=filled, fillcolor=yellow, fontcolor=black, size=0.5];
+    legend_orange [label="Fired->Empty Value", shape=box, style=filled, fillcolor=orange, fontcolor=black, size=0.5];
+    legend_red [label="Evaluated->Not Fired", shape=box, style=filled, fillcolor=red, fontcolor=black, size=0.5];
+    legend_white [label="Not Evaluated",  shape=box, style=filled, fillcolor=white, fontcolor=black, size=0.5];
+
+    // Invisible edges to arrange legend vertically
+    legend_white -> legend_red -> legend_orange -> legend_yellow -> legend_green [style=invis];
+}"""
+        for line in legend_dot_graph.splitlines():
+            yield "%s" % (line.strip())
         yield "}"
 
     def __iter_options(self, indent):
@@ -1915,6 +1962,12 @@ class FilteredDotExporter(object):
             msg = 'Could not remove temporary file %s' % dotfilename
             logger.warning(msg)
 
+    def to_source(self) -> Source:
+        """
+        Return the source code of the graph as a Source object.
+        """
+        return Source("\n".join(self), filename=self.name)
+
     @staticmethod
     def esc(value):
         """Escape Strings."""
@@ -1922,7 +1975,9 @@ class FilteredDotExporter(object):
 
 
 def render_tree(root: Node, use_dot_exporter: bool = False,
-                filename: str = "scrdr", only_nodes: List[Node] = None, show_in_console: bool = False):
+                filename: str = "scrdr", only_nodes: List[Node] = None, show_in_console: bool = False,
+                color_map: Optional[Callable[[Node], str]] = None,
+                view: bool = False) -> None:
     """
     Render the tree using the console and optionally export it to a dot file.
 
@@ -1931,6 +1986,8 @@ def render_tree(root: Node, use_dot_exporter: bool = False,
     :param filename: The name of the file to export the tree to.
     :param only_nodes: A list of nodes to include in the dot export.
     :param show_in_console: Whether to print the tree to the console.
+    :param color_map: A function that returns a color for certain nodes.
+    :param view: Whether to view the dot file in a viewer.
     """
     if not root:
         logger.warning("No rules to render")
@@ -1947,10 +2004,15 @@ def render_tree(root: Node, use_dot_exporter: bool = False,
                                  include_nodes=only_nodes,
                                  nodenamefunc=unique_node_names,
                                  edgeattrfunc=edge_attr_setter,
-                                 nodeattrfunc=lambda node: f'style=filled, fillcolor={node.color}'
+                                 nodeattrfunc=lambda node: f'style=filled,'
+                                                           f' fillcolor={color_map(node) if color_map else node.color}',
                                  )
-        de.to_dotfile(f"{filename}{'.dot'}")
-        # de.to_picture(f"{filename}{'.png'}")
+        if view:
+            de.to_source().view()
+        else:
+            filename = filename or "rule_tree"
+            de.to_dotfile(f"{filename}{'.dot'}")
+            de.to_picture(f"{filename}{'.svg'}")
 
 
 def draw_tree(root: Node, fig: Figure):

{ripple_down_rules-0.6.28.dist-info → ripple_down_rules-0.6.30.dist-info}/METADATA

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

@@ -0,0 +1,24 @@
+ripple_down_rules/__init__.py,sha256=97mtCfVEw1HwkdrprDGcbF2yNl3fqkWb_6oSEj-rOFo,99
+ripple_down_rules/experts.py,sha256=KXwWCmDrCffu9HW3yNewqWc1e5rnPI5Rnc981w_5M7U,17896
+ripple_down_rules/helpers.py,sha256=X1psHOqrb4_xYN4ssQNB8S9aRKKsqgihAyWJurN0dqk,5499
+ripple_down_rules/rdr.py,sha256=KsZbAbOs8U2PL19YOjFqSer8coXkSMDL3ztIrWHmTCA,62833
+ripple_down_rules/rdr_decorators.py,sha256=xoBGsIJMkJYUdsrsEaPZqoAsGuXkuVZAKCoP-xD2Iv8,11668
+ripple_down_rules/rules.py,sha256=W-y4aGKrGn2Xc7fbn1PNyz_jUzufFMtYwhLYiST28Ww,29213
+ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
+ripple_down_rules/utils.py,sha256=1fiSF4MOaOUrxlMz8sZA_e10258sMWuX5fG9WDawd2o,76674
+ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
+ripple_down_rules/datastructures/callable_expression.py,sha256=IrlnufVsKrUDLVkc2owoFQ05oSOby3HiGuNXoFVj4Dw,13494
+ripple_down_rules/datastructures/case.py,sha256=dfLnrjsHIVF2bgbz-4ID7OdQvw68V71btCeTK372P-g,15667
+ripple_down_rules/datastructures/dataclasses.py,sha256=3vX52WrAHgVyw0LUSgSBOVFaQNTSxU8hQpdr7cW-tSg,13278
+ripple_down_rules/datastructures/enums.py,sha256=CvcROl8fE7A6uTbMfs2lLpyxwS_ZFtFcQlBDDKFfoHc,6059
+ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/user_interface/gui.py,sha256=K6cvA9TOXIDpk0quGCamrWqDRlvz0QruDaTj4Y4PWWI,28544
+ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=RLdPqPxx-a0Sh74UZWyRBuxS_OKeXJnzoDfms4i-Aus,7710
+ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
+ripple_down_rules/user_interface/prompt.py,sha256=WPbw_8_-8SpF2ISyRZRuFwPKBEuGC4HaX3lbCPFHhh8,10314
+ripple_down_rules/user_interface/template_file_creator.py,sha256=uSbosZS15MOR3Nv7M3MrFuoiKXyP4cBId-EK3I6stHM,13660
+ripple_down_rules-0.6.30.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.6.30.dist-info/METADATA,sha256=5y9rt2-t0p_N1BJt2_fMrLzYk0KZl5W8uDDB27LHiWw,48294
+ripple_down_rules-0.6.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.6.30.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.6.30.dist-info/RECORD,,

ripple_down_rules-0.6.28.dist-info/RECORD

@@ -1,24 +0,0 @@
-ripple_down_rules/__init__.py,sha256=XvJJjrncdmKjrvKVVILZq7uuTOYiohoP3iLBN_oKp_M,99
-ripple_down_rules/experts.py,sha256=bQfDB7RZE_CANVkpBMb9bi8ZWFwk5p7hn1AzjpaO5ow,12877
-ripple_down_rules/helpers.py,sha256=X1psHOqrb4_xYN4ssQNB8S9aRKKsqgihAyWJurN0dqk,5499
-ripple_down_rules/rdr.py,sha256=hVqfCRrru6TUnqzY7yGMjiNnxUIFjfL2U7txmGNjeGI,61661
-ripple_down_rules/rdr_decorators.py,sha256=xoBGsIJMkJYUdsrsEaPZqoAsGuXkuVZAKCoP-xD2Iv8,11668
-ripple_down_rules/rules.py,sha256=N4dEx-xyqxGZpoEYzRd9P5u97_DcDEVLY_UiNhZ4E7g,28726
-ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=9xW0N2cB7X4taVANtLg-kVTPS-6ajWZylKkTqw2PKw4,73825
-ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
-ripple_down_rules/datastructures/callable_expression.py,sha256=P3o-z54Jt4rtIczeFWiuHFTNqMzYEOm94OyOP535D6Q,13378
-ripple_down_rules/datastructures/case.py,sha256=PJ7_-AdxYic6BO5z816piFODj6nU5J6Jt1YzTFH-dds,15510
-ripple_down_rules/datastructures/dataclasses.py,sha256=kI3Kv8GiVR8igMgA_BlKN6djUYxC2mLecvyh19pqQQA,10998
-ripple_down_rules/datastructures/enums.py,sha256=CvcROl8fE7A6uTbMfs2lLpyxwS_ZFtFcQlBDDKFfoHc,6059
-ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules/user_interface/gui.py,sha256=JCz6vA2kWVvRD6CupoUfMbtGz39cvUlmVnGnw_fY6OA,27635
-ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=yp-F8YRWGhj1PLB33HE6vJkdYWFN5Zn2244S2DUWRTM,6576
-ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
-ripple_down_rules/user_interface/prompt.py,sha256=nLIAviClSmVCY80vQgTazDPs4a1AYmNQmT7sksLDJpE,9449
-ripple_down_rules/user_interface/template_file_creator.py,sha256=kwBbFLyN6Yx2NTIHPSwOoytWgbJDYhgrUOVFw_jkDQ4,13522
-ripple_down_rules-0.6.28.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.6.28.dist-info/METADATA,sha256=fPfcVvFD7eEuG5FKX26HRRWPJkZatA0mfWdarnTqPa8,48294
-ripple_down_rules-0.6.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ripple_down_rules-0.6.28.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.6.28.dist-info/RECORD,,