ripple-down-rules 0.2.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

ripple_down_rules/user_interface/template_file_creator.py

@@ -0,0 +1,293 @@
+import ast
+import os
+import shutil
+import socket
+import subprocess
+import tempfile
+from functools import cached_property
+from textwrap import indent, dedent
+
+from colorama import Fore, Style
+from ipykernel.inprocess.ipkernel import InProcessInteractiveShell
+from typing_extensions import Optional, Type, List, Callable
+
+from ..datastructures.case import Case
+from ..datastructures.dataclasses import CaseQuery
+from ..datastructures.enums import Editor, PromptFor
+from ..utils import str_to_snake_case, get_imports_from_scope, make_list, typing_hint_to_str, \
+    get_imports_from_types, extract_function_source
+
+
+def detect_available_editor() -> Optional[Editor]:
+    """
+    Detect the available editor on the system.
+
+    :return: The first found editor that is available on the system.
+    """
+    editor_env = os.environ.get("RDR_EDITOR")
+    if editor_env:
+        return Editor.from_str(editor_env)
+    for editor in [Editor.Pycharm, Editor.Code, Editor.CodeServer]:
+        if shutil.which(editor.value):
+            return editor
+    return None
+
+
+def is_port_in_use(port: int = 8080) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(("localhost", port)) == 0
+
+
+def start_code_server(workspace):
+    """
+    Start the code-server in the given workspace.
+    """
+    filename = os.path.join(os.path.dirname(__file__), "start-code-server.sh")
+    os.system(f"chmod +x {filename}")
+    print(f"Starting code-server at {filename}")
+    return subprocess.Popen(["/bin/bash", filename, workspace], stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE, text=True)
+
+
+class TemplateFileCreator:
+    """
+    A class to create a rule template file for a given case and prompt for the user to edit it.
+    """
+    temp_file_path: Optional[str] = None
+    """
+    The path to the temporary file that is created for the user to edit.
+    """
+    port: int = int(os.environ.get("RDR_EDITOR_PORT", 8080))
+    """
+    The port to use for the code-server.
+    """
+    process: Optional[subprocess.Popen] = None
+    """
+    The process of the code-server.
+    """
+    all_code_lines: Optional[List[str]] = None
+    """
+    The list of all code lines in the function in the temporary file.
+    """
+
+    def __init__(self, shell: InProcessInteractiveShell, case_query: CaseQuery, prompt_for: PromptFor,
+                 code_to_modify: Optional[str] = None, print_func: Optional[Callable[[str], None]] = None):
+        self.print_func = print_func if print_func else print
+        self.shell = shell
+        self.code_to_modify = code_to_modify
+        self.prompt_for = prompt_for
+        self.case_query = case_query
+        self.output_type = self.get_output_type()
+        self.user_edit_line = 0
+        self.func_name: str = self.get_func_name()
+        self.func_doc: str = self.get_func_doc()
+        self.function_signature: str = self.get_function_signature()
+        self.editor: Optional[Editor] = detect_available_editor()
+        self.workspace: str = os.environ.get("RDR_EDITOR_WORKSPACE", os.path.dirname(self.case_query.scope['__file__']))
+        self.temp_file_path: str = os.path.join(self.workspace, "edit_code_here.py")
+
+    def get_output_type(self) -> List[Type]:
+        """
+        :return: The output type of the function as a list of types.
+        """
+        if self.prompt_for == PromptFor.Conditions:
+            output_type = bool
+        else:
+            output_type = self.case_query.attribute_type
+        return make_list(output_type) if output_type is not None else None
+
+    def edit(self):
+        if self.editor is None:
+            self.print_func(
+                f"{Fore.RED}ERROR:: No editor found. Please install PyCharm, VSCode or code-server.{Style.RESET_ALL}")
+            return
+
+        boilerplate_code = self.build_boilerplate_code()
+        self.write_to_file(boilerplate_code)
+
+        self.open_file_in_editor()
+
+    def open_file_in_editor(self):
+        """
+        Open the file in the available editor.
+        """
+        if self.editor == Editor.Pycharm:
+            subprocess.Popen(["pycharm", "--line", str(self.user_edit_line), self.temp_file_path],
+                             stdout=subprocess.DEVNULL,
+                             stderr=subprocess.DEVNULL)
+        elif self.editor == Editor.Code:
+            subprocess.Popen(["code", self.temp_file_path])
+        elif self.editor == Editor.CodeServer:
+            try:
+                subprocess.check_output(["pgrep", "-f", "code-server"])
+                # check if same port is in use
+                if is_port_in_use(self.port):
+                    self.print_func(f"Code-server is already running on port {self.port}.")
+                else:
+                    raise ValueError("Port is not in use.")
+            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}")
+
+    def build_boilerplate_code(self):
+        imports = self.get_imports()
+        if self.function_signature is None:
+            self.function_signature = self.get_function_signature()
+        if self.func_doc is None:
+            self.func_doc = self.get_func_doc()
+        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 get_function_signature(self) -> str:
+        if self.func_name is None:
+            self.func_name = self.get_func_name()
+        output_type_hint = self.get_output_type_hint()
+        func_args = self.get_func_args()
+        return f"def {self.func_name}({func_args}){output_type_hint}:"
+
+    def get_output_type_hint(self) -> str:
+        """
+        :return: A string containing the output type hint for the function.
+        """
+        output_type_hint = ""
+        if self.prompt_for == PromptFor.Conditions:
+            output_type_hint = " -> bool"
+        elif self.prompt_for == PromptFor.Conclusion:
+            output_type_hint = f" -> {self.case_query.attribute_type_hint}"
+        return output_type_hint
+
+    def get_func_args(self) -> str:
+        """
+        :return: A string containing the function arguments.
+        """
+        if self.case_query.is_function:
+            func_args = {}
+            for k, v in self.case_query.case.items():
+                if (self.case_query.function_args_type_hints is not None
+                        and k in self.case_query.function_args_type_hints):
+                    func_args[k] = typing_hint_to_str(self.case_query.function_args_type_hints[k])[0]
+                else:
+                    func_args[k] = type(v).__name__ if not isinstance(v, type) else f"Type[{v.__name__}]"
+            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__}"
+        return func_args
+
+    def write_to_file(self, code: str):
+        if self.temp_file_path is None:
+            tmp = tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix=".py",
+                                              dir=self.workspace)
+            tmp.write(code)
+            tmp.flush()
+            self.temp_file_path = tmp.name
+            tmp.close()
+        else:
+            with open(self.temp_file_path, 'w+') as f:
+                f.write(code)
+
+    def get_imports(self):
+        """
+        :return: A string containing the imports for the function.
+        """
+        case_type_imports = []
+        if self.case_query.is_function:
+            for k, v in self.case_query.case.items():
+                if (self.case_query.function_args_type_hints is not None
+                        and k in self.case_query.function_args_type_hints):
+                    hint_list = typing_hint_to_str(self.case_query.function_args_type_hints[k])[1]
+                    for hint in hint_list:
+                        hint_split = hint.split('.')
+                        if len(hint_split) > 1:
+                            case_type_imports.append(f"from {'.'.join(hint_split[:-1])} import {hint_split[-1]}")
+                else:
+                    if isinstance(v, type):
+                        case_type_imports.append(f"from {v.__module__} import {v.__name__}")
+                    elif hasattr(v, "__module__") and not v.__module__.startswith("__"):
+                        case_type_imports.append(f"\nfrom {type(v).__module__} import {type(v).__name__}")
+        else:
+            case_type_imports.append(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")
+            if list in self.output_type:
+                output_type_imports.append("from typing_extensions import List")
+        imports = get_imports_from_scope(self.case_query.scope)
+        imports = [i for i in imports if ("get_ipython" not in i)]
+        imports.extend(case_type_imports)
+        imports.extend([oti for oti in output_type_imports if oti not in imports])
+        imports = set(imports)
+        return '\n'.join(imports)
+
+    def get_func_doc(self) -> Optional[str]:
+        """
+        :return: A string containing the function docstring.
+        """
+        if self.prompt_for == PromptFor.Conditions:
+            return (f"Get conditions on whether it's possible to conclude a value"
+                    f" for {self.case_query.name}")
+        else:
+            return f"Get possible value(s) for {self.case_query.name}"
+
+    def get_func_name(self) -> Optional[str]:
+        func_name = ""
+        if self.prompt_for == PromptFor.Conditions:
+            func_name = f"{self.prompt_for.value.lower()}_for_"
+        case_name = self.case_query.name.replace(".", "_")
+        if self.case_query.is_function:
+            # convert any CamelCase word into snake_case by adding _ before each capital letter
+            case_name = case_name.replace(f"_{self.case_query.attribute_name}", "")
+        func_name += case_name
+        return str_to_snake_case(func_name)
+
+    @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.case_query.scope['case']
+        return case._obj_type if isinstance(case, Case) else type(case)
+
+    def load(self) -> Optional[List[str]]:
+        if not self.temp_file_path:
+            self.print_func(f"{Fore.RED}ERROR:: No file to load. Run %edit first.{Style.RESET_ALL}")
+            return None
+
+        with open(self.temp_file_path, 'r') as f:
+            source = f.read()
+
+        tree = ast.parse(source)
+        updates = {}
+        for node in tree.body:
+            if isinstance(node, ast.FunctionDef) and node.name == self.func_name:
+                exec_globals = {}
+                exec(source, self.case_query.scope, exec_globals)
+                user_function = exec_globals[self.func_name]
+                updates[self.func_name] = user_function
+                self.print_func(f"{Fore.BLUE}Loaded `{self.func_name}` function into user namespace.{Style.RESET_ALL}")
+                break
+        if updates:
+            self.shell.user_ns.update(updates)
+            self.all_code_lines = extract_function_source(self.temp_file_path,
+                                                          [self.func_name],
+                                                          join_lines=False)[self.func_name]
+            return self.all_code_lines
+        else:
+            self.print_func(f"{Fore.RED}ERROR:: Function `{self.func_name}` not found.{Style.RESET_ALL}")
+            return None
+
+    def __del__(self):
+        if hasattr(self, 'process') and self.process is not None and self.process.poll() is None:
+            self.process.terminate()  # Graceful shutdown
+            self.process.wait()  # Ensure cleanup

ripple_down_rules/utils.py

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

{ripple_down_rules-0.2.4.dist-info → ripple_down_rules-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.2.4
+Version: 0.4.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
@@ -702,6 +702,13 @@ SCRDR, MCRDR, and GRDR implementation were inspired from the book:
 sudo apt-get install graphviz graphviz-dev
 pip install ripple_down_rules
 ```
+For GUI support, also install:
+
+```bash
+sudo apt-get install libxcb-cursor-dev
+```
+
+```bash
 
 ## Example Usage
 

ripple_down_rules-0.4.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/datasets.py,sha256=fJbZ7V-UUYTu5XVVpFinTbuzN3YePCnUB01L3AyZVM8,6837
+ripple_down_rules/experts.py,sha256=S-d1EZP0SK0Ab_pMzgkOcLvZFLMdSm8_C0u3AgfouUc,6468
+ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
+ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
+ripple_down_rules/rdr.py,sha256=UhFKsb7bCKLfplZhCSY-FAulvMfsBqVk_-K7o5WMP4o,43709
+ripple_down_rules/rdr_decorators.py,sha256=VdmE0JrE8j89b6Af1R1tLZiKfy3h1VCvhAUefN_FLLQ,6753
+ripple_down_rules/rules.py,sha256=QQy7NBG6mKiowxVG_LjQJBxLTDW2hMyx5zAgwUxdCMM,17183
+ripple_down_rules/utils.py,sha256=tmYlbL1q8Au7iXlWNUW2j80pKqSaz6tvgwzL3fL5Cg8,48935
+ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
+ripple_down_rules/datastructures/callable_expression.py,sha256=jA7424_mWPbOoPICW3eLMX0-ypxnsW6gOqxrJ7JpDbE,11610
+ripple_down_rules/datastructures/case.py,sha256=oC8OSdhXvHE-Zx1IIQlad-fsKzQQqr6MZBW24c-dbeU,15191
+ripple_down_rules/datastructures/dataclasses.py,sha256=GWnUF4h4zfNHSsyBIz3L9y8sLkrXRv0FK_OxzzLc8L8,8183
+ripple_down_rules/datastructures/enums.py,sha256=ce7tqS0otfSTNAOwsnXlhsvIn4iW_Y_N3TNebF3YoZs,5700
+ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/user_interface/gui.py,sha256=xjuJCEhZ4Oy59AZQDjftcgOce76T6PWMhX5eq4sFLWU,25703
+ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=tc7ms80iPNElm9AYC6i1FlfMKkqHLT8wmOEXg_k9yAU,6275
+ripple_down_rules/user_interface/object_diagram.py,sha256=TaAsjCbsCBAsO1Ffp6l8otbK-mculUW2jnVrDRFq1hU,4249
+ripple_down_rules/user_interface/prompt.py,sha256=tQyIrRno1YuS3K0c4p48FVTdDJGG0HCE63WHVKpSJ1I,7976
+ripple_down_rules/user_interface/template_file_creator.py,sha256=PegwW_g8UScjEF2GGe1eV0VoWUzxPhA27L9ExbL7Y_E,12610
+ripple_down_rules-0.4.0.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.4.0.dist-info/METADATA,sha256=HAmijc0VYsXxNqGWwnGems2bOKDhJczdDdqbTgdzyNs,42668
+ripple_down_rules-0.4.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+ripple_down_rules-0.4.0.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.4.0.dist-info/RECORD,,

{ripple_down_rules-0.2.4.dist-info → ripple_down_rules-0.4.0.dist-info}/WHEEL

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