ripple-down-rules 0.5.4__py3-none-any.whl → 0.5.7__py3-none-any.whl

ripple_down_rules/utils.py

@@ -10,13 +10,16 @@ import os
 import re
 import threading
 import uuid
-from collections import UserDict
+from collections import UserDict, defaultdict
 from copy import deepcopy, copy
 from dataclasses import is_dataclass, fields
 from enum import Enum
+from os.path import dirname
 from textwrap import dedent
 from types import NoneType
-from typing import List
+
+from sqlalchemy.exc import NoInspectionAvailable
+
 
 try:
     import matplotlib
@@ -41,8 +44,7 @@ from sqlalchemy import MetaData, 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, \
-    get_origin, get_args, Tuple, Optional, List, Union, Self
-
+    get_origin, get_args, Tuple, Optional, List, Union, Self, ForwardRef
 
 if TYPE_CHECKING:
     from .datastructures.case import Case
@@ -81,7 +83,7 @@ def are_results_subclass_of_types(result_types: List[Any], types_: List[Type]) -
     return True
 
 
-def get_imports_from_types(types: List[Type]) -> List[str]:
+def _get_imports_from_types(types: List[Type]) -> List[str]:
     """
     Get the import statements for a list of types.
 
@@ -114,7 +116,7 @@ def get_imports_from_scope(scope: Dict[str, Any]) -> List[str]:
     """
     imports = []
     for k, v in scope.items():
-        if not hasattr(v, "__module__") or not hasattr(v, "__name__"):
+        if not hasattr(v, "__module__") or not hasattr(v, "__name__") or v.__module__ is None:
             continue
         imports.append(f"from {v.__module__} import {v.__name__}")
     return imports
@@ -157,7 +159,7 @@ def extract_function_source(file_path: str,
                             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]]]]:
+        Tuple[Dict[str, Union[str, List[str]]], Dict[str, Tuple[int, int]]]]:
     """
     Extract the source code of a function from a file.
 
@@ -176,7 +178,7 @@ 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]]] = {}
-    line_numbers = []
+    line_numbers: Dict[str, Tuple[int, int]] = {}
     for node in tree.body:
         if isinstance(node, ast.FunctionDef) and (node.name in function_names or len(function_names) == 0):
             # Get the line numbers of the function
@@ -184,7 +186,7 @@ def extract_function_source(file_path: str,
             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))
+            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
@@ -496,16 +498,8 @@ def serialize_dataclass(obj: Any, seen=None) -> Any:
             value = getattr(obj, f.name)
             result['fields'][f.name] = serialize_dataclass(value, seen)
         return result
-    elif isinstance(obj, list):
-        return [serialize_dataclass(v, seen) for v in obj]
-    elif isinstance(obj, dict):
-        return {k: serialize_dataclass(v, seen) for k, v in obj.items()}
     else:
-        try:
-            json.dumps(obj)  # Check if the object is JSON serializable
-            return obj
-        except TypeError:
-            return None
+        return SubclassJSONSerializer.to_json_static(obj, seen)
 
 
 def deserialize_dataclass(data: Any, refs: Optional[Dict[str, Any]] = None) -> Any:
@@ -667,56 +661,203 @@ def get_func_rdr_model_name(func: Callable, include_file_name: bool = False) ->
     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])
+def stringify_hint(tp):
+    """Recursively convert a type hint to a string."""
+    if isinstance(tp, str):
+        return tp
+
+    # Handle ForwardRef (string annotations not yet evaluated)
+    if isinstance(tp, ForwardRef):
+        return tp.__forward_arg__
+
+    # Handle typing generics like List[int], Dict[str, List[int]], etc.
+    origin = get_origin(tp)
+    args = get_args(tp)
+
+    if origin is not None:
+        origin_str = getattr(origin, '__name__', str(origin)).capitalize()
+        args_str = ", ".join(stringify_hint(arg) for arg in args)
+        return f"{origin_str}[{args_str}]"
+
+    # Handle built-in types like int, str, etc.
+    if isinstance(tp, type):
+        if tp.__module__ == 'builtins':
+            return tp.__name__
+        return f"{tp.__qualname__}"
+
+    return str(tp)
+
+
+def is_builtin_type(tp):
+    return isinstance(tp, type) and tp.__module__ == "builtins"
+
+
+def is_typing_type(tp):
+    return tp.__module__ == "typing"
+
+origin_type_to_hint = {
+    list: List,
+    set: Set,
+    dict: Dict,
+    tuple: Tuple,
+}
+
+def extract_types(tp, seen: Set = None) -> Set[type]:
+    """Recursively extract all base types from a type hint."""
+    if seen is None:
+        seen = set()
+
+    if tp in seen or isinstance(tp, str):
+        return seen
+
+    # seen.add(tp)
+
+    if isinstance(tp, ForwardRef):
+        # Can't resolve until evaluated
+        return seen
+
+    origin = get_origin(tp)
+    args = get_args(tp)
+
+    if origin:
+        if origin in origin_type_to_hint:
+            seen.add(origin_type_to_hint[origin])
+        else:
+            seen.add(origin)
+        for arg in args:
+            extract_types(arg, seen)
+
+    elif isinstance(tp, type):
+        seen.add(tp)
+
+    return seen
+
+
+def get_types_to_import_from_func_type_hints(func: Callable) -> Set[Type]:
+    """
+    Extract importable types from a function's annotations.
+
+    :param func: The function to extract type hints from.
+    """
+    hints = get_type_hints(func)
+
+    sig = inspect.signature(func)
+    all_hints = list(hints.values())
+    if sig.return_annotation != inspect.Signature.empty:
+        all_hints.append(sig.return_annotation)
+
+    for param in sig.parameters.values():
+        if param.annotation != inspect.Parameter.empty:
+            all_hints.append(param.annotation)
+
+    return get_types_to_import_from_type_hints(all_hints)
+
+
+def get_types_to_import_from_type_hints(hints: List[Type]) -> Set[Type]:
+    """
+    Extract importable types from a list of type hints.
+
+    :param hints: A list of type hints to extract types from.
+    :return: A set of types that need to be imported.
+    """
+    seen_types = set()
+    for hint in hints:
+        extract_types(hint, seen_types)
+
+    # Filter out built-in and internal types
+    to_import = set()
+    for tp in seen_types:
+        if isinstance(tp, ForwardRef) or isinstance(tp, str):
+            continue
+        if not is_builtin_type(tp):
+            to_import.add(tp)
+
+    return to_import
+
+
+def get_import_path_from_path(path: str) -> Optional[str]:
+    """
+    Convert a file system path to a Python import path.
+
+    :param path: The file system path to convert.
+    :return: The Python import path.
+    """
+    package_name = os.path.abspath(path)
+    formated_package_name = package_name.strip('./').replace('/', '.')
+    parent_package_idx = 0
+    packages = formated_package_name.split('.')
+    for i, possible_pacakge in enumerate(reversed(packages)):
+        if i == 0:
+            current_path = package_name
+        else:
+            current_path = '/' + '/'.join(packages[:-i])
+        if os.path.exists(os.path.join(current_path, '__init__.py')):
+            parent_package_idx -= 1
+        else:
+            break
+    package_name = '.'.join(packages[parent_package_idx:]) if parent_package_idx < 0 else None
+    return package_name
+
+
+def get_function_import_path_and_representation(func: Callable) -> Tuple[str, str]:
+    """
+    Get the import path of a function.
+
+    :param func: The function to get the import path for.
+    :return: The import path of the function.
+    """
+    func_name = get_method_name(func)
+    func_class_name = get_method_class_name_if_exists(func)
+    func_file_path = get_method_file_name(func)
+    func_file_name = func_file_path.split('/')[-1].split('.')[0]  # Get the file name without extension
+    func_import_path = get_import_path_from_path(dirname(func_file_path))
+    func_import_path = f"{func_import_path}.{func_file_name}" if func_import_path else func_file_name
+    if func_class_name and func_class_name != func_name:
+        import_path = f"from {func_import_path} import {func_class_name}"
+        func_representation = f"{func_class_name}.{func_name}"
     else:
-        val = val.split('.')[-1]
-    return val, all_args
+        import_path = f"from {func_import_path} import {func_name}"
+        func_representation = func_name
+    return import_path, func_representation
+
+
+def get_imports_from_types(type_objs: List[Type]) -> List[str]:
+    """
+    Format import lines from type objects.
+
+    :param type_objs: A list of type objects to format.
+    """
+
+    module_to_types = defaultdict(list)
+    other_imports = []
+    for tp in type_objs:
+        try:
+            if isinstance(tp, type) or is_typing_type(tp):
+                module = tp.__module__
+                name = tp.__qualname__
+            elif callable(tp):
+                import_, _ = get_function_import_path_and_representation(tp)
+                if import_ is not None:
+                    other_imports.append(import_)
+                module = None
+            elif hasattr(type(tp), "__module__"):
+                module = type(tp).__module__
+                name = type(tp).__qualname__
+            else:
+                continue
+            if module is None or module == 'builtins' or module.startswith('_'):
+                continue
+            module_to_types[module].append(name)
+        except AttributeError:
+            continue
+
+    lines = []
+    for module, names in module_to_types.items():
+        joined = ", ".join(sorted(set(names)))
+        lines.append(f"from {module} import {joined}")
+    if other_imports:
+        lines.extend(other_imports)
+    return sorted(lines)
 
 
 def get_method_args_as_dict(method: Callable, *args, **kwargs) -> Dict[str, Any]:
@@ -753,7 +894,9 @@ def get_method_class_name_if_exists(method: Callable) -> Optional[str]:
     :return: The class name of the method.
     """
     if hasattr(method, "__self__"):
-        if hasattr(method.__self__, "__class__"):
+        if hasattr(method.__self__, "__name__"):
+            return method.__self__.__name__
+        elif hasattr(method.__self__, "__class__"):
             return method.__self__.__class__.__name__
     return method.__qualname__.split('.')[0] if hasattr(method, "__qualname__") else None
 
@@ -869,10 +1012,28 @@ class SubclassJSONSerializer:
         return data
 
     @staticmethod
-    def to_json_static(obj) -> Dict[str, Any]:
-        if is_dataclass(obj):
-            return serialize_dataclass(obj)
-        return {"_type": get_full_class_name(obj.__class__), **obj._to_json()}
+    def to_json_static(obj, seen=None) -> Any:
+        if isinstance(obj, SubclassJSONSerializer):
+            return {"_type": get_full_class_name(obj.__class__), **obj._to_json()}
+        elif isinstance(obj, type):
+            return {"_type": get_full_class_name(obj)}
+        elif is_dataclass(obj):
+            return serialize_dataclass(obj, seen)
+        elif isinstance(obj, list):
+            return [SubclassJSONSerializer.to_json_static(v, seen) for v in obj]
+        elif isinstance(obj, dict):
+            serialized_dict = {}
+            for k, v in obj.items():
+                if not isinstance(k, (str, int, bool, float, type(None))):
+                    continue
+                serialized_dict[k] = SubclassJSONSerializer.to_json_static(v, seen)
+            return serialized_dict
+        else:
+            try:
+                json.dumps(obj)  # Check if the object is JSON serializable
+                return obj
+            except TypeError:
+                return None
 
     def to_json(self) -> Dict[str, Any]:
         return self.to_json_static(self)
@@ -1008,13 +1169,20 @@ def copy_orm_instance(instance: SQLTable) -> SQLTable:
     :param instance: The instance to copy.
     :return: The copied instance.
     """
-    session: Session = inspect(instance).session
+    try:
+        session: Session = inspect(instance).session
+    except NoInspectionAvailable:
+        session = None
     if session is not None:
         session.expunge(instance)
         new_instance = deepcopy(instance)
         session.add(instance)
     else:
-        new_instance = instance
+        try:
+            new_instance = deepcopy(instance)
+        except Exception as e:
+            logging.debug(e)
+            new_instance = instance
     return new_instance
 
 
@@ -1028,8 +1196,12 @@ def copy_orm_instance_with_relationships(instance: SQLTable) -> SQLTable:
     instance_cp = copy_orm_instance(instance)
     for rel in class_mapper(instance.__class__).relationships:
         related_obj = getattr(instance, rel.key)
+        related_obj_cp = copy_orm_instance(related_obj)
         if related_obj is not None:
-            setattr(instance_cp, rel.key, related_obj)
+            try:
+                setattr(instance_cp, rel.key, related_obj_cp)
+            except Exception as e:
+                logging.debug(e)
     return instance_cp
 
 
@@ -1040,7 +1212,17 @@ def get_value_type_from_type_hint(attr_name: str, obj: Any) -> Type:
     :param attr_name: The name of the attribute.
     :param obj: The object to get the attributes from.
     """
-    hint, origin, args = get_hint_for_attribute(attr_name, obj)
+    # check first if obj is a function object
+    if hasattr(obj, '__code__'):
+        func_type_hints = get_type_hints(obj)
+        if attr_name in func_type_hints:
+            hint = func_type_hints[attr_name]
+            origin = get_origin(hint)
+            args = get_args(hint)
+        else:
+            raise ValueError(f"Unknown type hint: {attr_name}")
+    else:
+        hint, origin, args = get_hint_for_attribute(attr_name, obj)
     if not origin and not hint:
         if hasattr(obj, attr_name):
             attr_value = getattr(obj, attr_name)
@@ -1370,8 +1552,8 @@ def draw_tree(root: Node, fig: 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 matplotlib.get_backend().lower() not in ['qt5agg', 'qt4agg', 'qt6agg']:
+    #     matplotlib.use("Qt6Agg")  # or "Qt6Agg", depending on availability
 
     if root is None:
         return

{ripple_down_rules-0.5.4.dist-info → ripple_down_rules-0.5.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.4
+Version: 0.5.7
 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
@@ -693,7 +693,8 @@ Requires-Dist: colorama
 Requires-Dist: pygments
 Requires-Dist: sqlalchemy
 Requires-Dist: pandas
-Requires-Dist: pyparsing
+Requires-Dist: pyparsing>=3.2.3
+Requires-Dist: omegaconf
 Provides-Extra: viz
 Requires-Dist: networkx>=3.1; extra == "viz"
 Requires-Dist: matplotlib>=3.7.5; extra == "viz"
@@ -799,6 +800,19 @@ cat = grdr.classify(all_cases[50])['species']
 assert cat == targets[50]
 ```
 
+When prompted to write a rule, I wrote the following inside the template function that the Ripple Down Rules created:
+```python
+return case.milk == 1
+```
+then
+```python
+return case.aquatic == 1
+```
+
+The rule tree generated from fitting all the dataset will look like this:
+![species_rdr](https://raw.githubusercontent.com/AbdelrhmanBassiouny/ripple_down_rules/main/images/scrdr.png)
+
+
 ### Relational Example
 
 By relational, I mean that each rule conclusion is not a constant value, but is related to the case being classified,

ripple_down_rules-0.5.7.dist-info/RECORD

@@ -0,0 +1,24 @@
+ripple_down_rules/__init__.py,sha256=rFBuJJIKkCvrrCTAQhdvytf-dk066UDS2ltMWPx7WIo,99
+ripple_down_rules/experts.py,sha256=bwozulI1rv0uyaMZQqEgapDO-s8wvW0D6Jqxmvu5fik,12610
+ripple_down_rules/helpers.py,sha256=v4oE7C5PfQUVJfSUs1FfLHEwrJXEHJLn4vJhJMvyCR8,4453
+ripple_down_rules/rdr.py,sha256=5VeA6YT16SL-sZK3VYiZ6vqazqZzCj_Uhk7xKYyqwVA,51354
+ripple_down_rules/rdr_decorators.py,sha256=pEVupcFqtHzPCaxZoxphHWlrSN6vCishdwUQ1hXiWtc,9193
+ripple_down_rules/rules.py,sha256=rIFE5OIJpuXrquTPAXXOTuatWBD7CkWqRMnDmItLwUc,20176
+ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
+ripple_down_rules/utils.py,sha256=yeSW2KvnxHTL2FMi-95-K6RmcMdzubJBc-jHeMPLL0g,56961
+ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
+ripple_down_rules/datastructures/callable_expression.py,sha256=f3wUPTrLa1INO-1qfgVz87ryrCABronfyq0_JKWoZCs,12800
+ripple_down_rules/datastructures/case.py,sha256=1zSaXUljaH6z3SgMGzYPoDyjotNam791KpYgvxuMh90,15463
+ripple_down_rules/datastructures/dataclasses.py,sha256=vlMmlsFJs3s71fwE8d79x_f8z6ZNcLGC5gjSAqabWxY,11021
+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=_lgZAUXxxaBUFQJAHjA5TBPp6XEvJ62t-kSN8sPsocE,27379
+ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=Jrf7NxOdlrwGXH0Xyz3vzQprY-PNx9etfePOTpm2Gu8,6479
+ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
+ripple_down_rules/user_interface/prompt.py,sha256=AkkltdDIaioN43lkRKDPKSjJcmdSSGZDMYz7AL7X9lE,8082
+ripple_down_rules/user_interface/template_file_creator.py,sha256=VLS9Nxg6gPNa-YYliJ_VNsTvLPlZ003EVkJ2t8zuDgE,13563
+ripple_down_rules-0.5.7.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.5.7.dist-info/METADATA,sha256=IfSm2_mYstp-Xn7qpzoEOSJo_nXQ4Aw5Uc6Oke65nBk,48213
+ripple_down_rules-0.5.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.5.7.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.5.7.dist-info/RECORD,,

{ripple_down_rules-0.5.4.dist-info → ripple_down_rules-0.5.7.dist-info}/WHEEL

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

ripple_down_rules-0.5.4.dist-info/RECORD

@@ -1,24 +0,0 @@
-ripple_down_rules/__init__.py,sha256=8e_vgenmdqtVY41f0q59EP97pFvgSGxtQgPyO9fnp64,99
-ripple_down_rules/experts.py,sha256=rPRJU2py5wCopZADVWOP3Vzp077KL6ArDlkxUQ0Mh6w,12130
-ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
-ripple_down_rules/rdr.py,sha256=FJYuRXgpUYSSK1pYrp2yeXb_ZZ2xjPED31tzxofokL4,48865
-ripple_down_rules/rdr_decorators.py,sha256=pYCKLgMKgQ6x_252WQtF2t4ZNjWPBxnaWtJ6TpGdcc0,7820
-ripple_down_rules/rules.py,sha256=TPNVMqW9T-_46BS4WemrspLg5uG8kP6tsPvWWBAzJxg,17515
-ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=cv40XBj-tp11aRYcAPhPtkrYatMvAKk_1d5P7PB1-tw,51123
-ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
-ripple_down_rules/datastructures/callable_expression.py,sha256=D2KD1RdShzxYZPAERgywZ5ZPE4ar8WmMtXINqvYo_Tc,12497
-ripple_down_rules/datastructures/case.py,sha256=r8kjL9xP_wk84ThXusspgPMrAoed2bGQmKi54fzhmH8,15258
-ripple_down_rules/datastructures/dataclasses.py,sha256=PuD-7zWqWT2p4FnGvnihHvZlZKg9A1ctnFgVYf2cs-8,8554
-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=SB0gUhgReJ3yx-NEHRPMGVuNRLPRUwW8-qup-Kd4Cfo,27182
-ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=24MIFwqnAhC6ofObEO6x5xRWRnyQmPpPmTvxbCKBrzM,6514
-ripple_down_rules/user_interface/object_diagram.py,sha256=tsB6iuLNEbHxp5lR2WjyejjWbnAX_nHF9xS8jNPOQVk,4548
-ripple_down_rules/user_interface/prompt.py,sha256=AkkltdDIaioN43lkRKDPKSjJcmdSSGZDMYz7AL7X9lE,8082
-ripple_down_rules/user_interface/template_file_creator.py,sha256=ycCbddy_BJP8d0Q2Sj21UzamhGtqGZuK_e73VTJqznY,13766
-ripple_down_rules-0.5.4.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.5.4.dist-info/METADATA,sha256=2t5F_Z7AqI7lb2zZxTREAGEUyipcISlZ00Dk-0BAEx4,47796
-ripple_down_rules-0.5.4.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-ripple_down_rules-0.5.4.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.5.4.dist-info/RECORD,,