ripple-down-rules 0.5.5__py3-none-any.whl → 0.5.8__py3-none-any.whl

ripple_down_rules/utils.py

@@ -8,15 +8,20 @@ import json
 import logging
 import os
 import re
+import sys
 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 pathlib import Path
 from textwrap import dedent
 from types import NoneType
-from typing import List
+
+from sqlalchemy.exc import NoInspectionAvailable
+
 
 try:
     import matplotlib
@@ -41,8 +46,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, Sequence, Iterable
 
 if TYPE_CHECKING:
     from .datastructures.case import Case
@@ -81,7 +85,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,13 +118,21 @@ 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
 
 
-def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = None) -> Dict[str, Any]:
+def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = None,
+                    package_name: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Extract imports from a Python file or an AST tree.
+
+    :param file_path: The path to the Python file to extract imports from.
+    :param tree: An AST tree to extract imports from. If provided, file_path is ignored.
+    :param package_name: The name of the package to use for relative imports.
+    """
     if tree is None:
         if file_path is None:
             raise ValueError("Either file_path or tree must be provided")
@@ -135,7 +147,7 @@ def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = N
                 module_name = alias.name
                 asname = alias.asname or alias.name
                 try:
-                    scope[asname] = importlib.import_module(module_name)
+                    scope[asname] = importlib.import_module(module_name, package=package_name)
                 except ImportError as e:
                     print(f"Could not import {module_name}: {e}")
         elif isinstance(node, ast.ImportFrom):
@@ -144,7 +156,12 @@ def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = N
                 name = alias.name
                 asname = alias.asname or name
                 try:
-                    module = importlib.import_module(module_name)
+                    if package_name is not None and node.level > 0: # Handle relative imports
+                        module_rel_path = Path(os.path.join(file_path, *['..'] * node.level, module_name)).resolve()
+                        idx = str(module_rel_path).rfind(package_name)
+                        if idx != -1:
+                            module_name = str(module_rel_path)[idx:].replace(os.path.sep, '.')
+                    module = importlib.import_module(module_name, package=package_name)
                     scope[asname] = getattr(module, name)
                 except (ImportError, AttributeError) as e:
                     logging.warning(f"Could not import {module_name}: {e} while extracting imports from {file_path}")
@@ -157,7 +174,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 +193,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 +201,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 +513,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 +676,257 @@ 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_data(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:
+        func_import_name = func_class_name
     else:
-        val = val.split('.')[-1]
-    return val, all_args
+        func_import_name = func_name
+    return func_import_path, func_import_name
+
+
+def get_function_representation(func: Callable) -> str:
+    """
+    Get a string representation of a function, including its module and class if applicable.
+
+    :param func: The function to represent.
+    :return: A string representation of the function.
+    """
+    func_name = get_method_name(func)
+    func_class_name = get_method_class_name_if_exists(func)
+    if func_class_name and func_class_name != func_name:
+        return f"{func_class_name}.{func_name}"
+    return func_name
+
+
+def get_relative_import(target_file_path, imported_module_path: Optional[str] = None,
+                        module: Optional[str] = None) -> str:
+    """
+    Get a relative import path from the target file to the imported module.
+
+    :param target_file_path: The file path of the target file.
+    :param imported_module_path: The file path of the module being imported.
+    :param module: The module name, if available.
+    :return: A relative import path as a string.
+    """
+    # Convert to absolute paths
+    if module is not None:
+        imported_module_path = sys.modules[module].__file__
+    if imported_module_path is None:
+        raise ValueError("Either imported_module_path or module must be provided")
+    target_path = Path(target_file_path).resolve()
+    imported_path = Path(imported_module_path).resolve()
+
+    # Compute relative path from target to imported module
+    rel_path = os.path.relpath(imported_path.parent, target_path.parent)
+
+    # Convert path to Python import format
+    rel_parts = [part.replace('..', '.') for part in Path(rel_path).parts]
+    rel_parts = rel_parts if rel_parts else ['']
+
+    # Join the parts and add the module name
+    joined_parts = "".join(rel_parts) + f".{imported_path.stem}"
+    joined_parts = f".{joined_parts}" if not joined_parts.startswith(".") else joined_parts
+
+    return joined_parts
+
+
+def get_imports_from_types(type_objs: Iterable[Type],
+                           target_file_path: Optional[str] = None,
+                           package_name: Optional[str] = None) -> List[str]:
+    """
+    Format import lines from type objects.
+
+    :param type_objs: A list of type objects to format.
+    :param target_file_path: The file path to which the imports should be relative.
+    :param package_name: The name of the package to use for relative imports.
+    """
+
+    module_to_types = defaultdict(list)
+    module_to_path = {}
+    other_imports = []
+    for tp in type_objs:
+        try:
+            if isinstance(tp, type) or is_typing_type(tp):
+                module = tp.__module__
+                file = getattr(tp, '__file__', None)
+                name = tp.__qualname__
+            elif callable(tp):
+                module, name = get_function_import_data(tp)
+                file = get_method_file_name(tp)
+            elif hasattr(type(tp), "__module__"):
+                module = type(tp).__module__
+                file = getattr(tp, '__file__', None)
+                name = type(tp).__qualname__
+            else:
+                continue
+            if module is None or module == 'builtins' or module.startswith('_'):
+                continue
+            module_to_types[module].append(name)
+            if file:
+                module_to_path[module] = file
+        except AttributeError:
+            continue
+
+    lines = []
+    for module, names in module_to_types.items():
+        joined = ", ".join(sorted(set(names)))
+        import_path = module
+        if (target_file_path is not None) and (package_name is not None) and (package_name in module):
+            import_path = get_relative_import(target_file_path, module=module)
+        lines.append(f"from {import_path} 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 +963,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 +1081,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 +1238,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 +1265,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 +1281,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)

{ripple_down_rules-0.5.5.dist-info → ripple_down_rules-0.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.5
+Version: 0.5.8
 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
@@ -694,6 +694,7 @@ Requires-Dist: pygments
 Requires-Dist: sqlalchemy
 Requires-Dist: pandas
 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"

ripple_down_rules-0.5.8.dist-info/RECORD

@@ -0,0 +1,24 @@
+ripple_down_rules/__init__.py,sha256=cwOHhynJm6Y-t455Unt4AXAxXv4yPEGHMxCLjDfdT_o,99
+ripple_down_rules/experts.py,sha256=bwozulI1rv0uyaMZQqEgapDO-s8wvW0D6Jqxmvu5fik,12610
+ripple_down_rules/helpers.py,sha256=v4oE7C5PfQUVJfSUs1FfLHEwrJXEHJLn4vJhJMvyCR8,4453
+ripple_down_rules/rdr.py,sha256=2t04Qj931dh6UypLBy4RxJ5hFIui0ejFgvm7D5P8b-E,55118
+ripple_down_rules/rdr_decorators.py,sha256=0sk7izDB53lTKSB9fm33vQahmY_05FyCOWljyQOMB0U,9072
+ripple_down_rules/rules.py,sha256=iVevv6iZ-6L2IPI0ZYbBjxBymXEQMmJGRFhiKUS-NmA,20352
+ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
+ripple_down_rules/utils.py,sha256=mObBszTruGrRvD4MgD8tS1AnMtoyKrPl4RCciinhzY4,60132
+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=qoTFHV8Hi-X8VtfC9VdvH4tif73YjF3dUe8dyHXTYts,10993
+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=xWUt-RHRqrvoMo74o-bMLo8xNxil68wgbOZAMADZp2A,13570
+ripple_down_rules-0.5.8.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.5.8.dist-info/METADATA,sha256=bY7Ex1Qpazl71BzyF1sfOdNB3Tny73pQRGBte2oareU,48213
+ripple_down_rules-0.5.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.5.8.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.5.8.dist-info/RECORD,,

ripple_down_rules-0.5.5.dist-info/RECORD

@@ -1,24 +0,0 @@
-ripple_down_rules/__init__.py,sha256=OV_GxE_svT43w1V5gHpc0YaGCqmA-cm_U7P8UmX4Ox4,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=4xQ5gmIeMsY-mA9g-4cedKt2WJq4oZAMs5XEKeplWPM,51127
-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=FGtLfYBfr4310c7Dfa9b2qiOWLNzHk1q3kdhD70Ilg4,13804
-ripple_down_rules-0.5.5.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.5.5.dist-info/METADATA,sha256=irk6Cn48hjgyNiE9XyuRsSFP1svBynaDMTkN1ijbvRc,48188
-ripple_down_rules-0.5.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ripple_down_rules-0.5.5.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.5.5.dist-info/RECORD,,