ripple-down-rules 0.4.86__py3-none-any.whl → 0.5.0__py3-none-any.whl

ripple_down_rules/__init__.py

@@ -1 +1,5 @@
-__version__ = "0.4.86"
+__version__ = "0.5.00"
+
+import logging
+logger = logging.Logger("rdr")
+logger.setLevel(logging.INFO)

ripple_down_rules/datastructures/callable_expression.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import ast
 import logging
+import os
 from _ast import AST
 from enum import Enum
 
@@ -10,7 +11,7 @@ from typing_extensions import Type, Optional, Any, List, Union, Tuple, Dict, Set
 from .case import create_case, Case
 from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string, conclusion_to_json, is_iterable, \
     build_user_input_from_conclusion, encapsulate_user_input, extract_function_source, are_results_subclass_of_types, \
-    make_list
+    make_list, get_imports_from_scope
 
 
 class VariableVisitor(ast.NodeVisitor):
@@ -175,6 +176,24 @@ class CallableExpression(SubclassJSONSerializer):
             return
         self.user_input = self.encapsulating_function + '\n' + new_function_body
 
+    def write_to_python_file(self, file_path: str, append: bool = False):
+        """
+        Write the callable expression to a python file.
+
+        :param file_path: The path to the file where the callable expression will be written.
+        :param append: If True, the callable expression will be appended to the file. If False,
+         the file will be overwritten.
+        """
+        imports = '\n'.join(get_imports_from_scope(self.scope))
+        if append and os.path.exists(file_path):
+            with open(file_path, 'a') as f:
+                f.write('\n\n\n' + imports + '\n\n\n')
+                f.write(self.user_input)
+        else:
+            with open(file_path, 'w') as f:
+                f.write(imports + '\n\n\n')
+                f.write(self.user_input)
+
     @property
     def user_input(self):
         """

ripple_down_rules/datastructures/case.py

@@ -354,11 +354,13 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] =
         if last_evaluated_rule and last_evaluated_rule.fired:
             corner_row_dict = copy_case(corner_case)
 
+    case_dict.update(targets)
+    case_dict.update(current_conclusions)
+    all_table_rows = [case_dict]
     if corner_row_dict:
         corner_conclusion = last_evaluated_rule.conclusion(case)
         corner_row_dict.update({corner_conclusion.__class__.__name__: corner_conclusion})
-        print(table_rows_as_str(corner_row_dict))
-    print("=" * 50)
-    case_dict.update(targets)
-    case_dict.update(current_conclusions)
-    print(table_rows_as_str(case_dict))
+        all_table_rows.append(corner_row_dict)
+        # print(table_rows_as_str(corner_row_dict))
+    print("\n" + "=" * 50)
+    print(table_rows_as_str(all_table_rows))

ripple_down_rules/datastructures/dataclasses.py

@@ -78,7 +78,15 @@ class CaseQuery:
         """
         :return: The type of the case that the attribute belongs to.
         """
-        return self.original_case._obj_type if isinstance(self.original_case, Case) else type(self.original_case)
+        if self.is_function:
+            if self.function_args_type_hints is not None:
+                func_args = [arg for name, arg in self.function_args_type_hints.items() if name != 'return']
+                case_type_args = Union[tuple(func_args)]
+            else:
+                case_type_args = Any
+            return Dict[str, case_type_args]
+        else:
+            return self.original_case._obj_type if isinstance(self.original_case, Case) else type(self.original_case)
 
     @property
     def case(self) -> Any:

ripple_down_rules/experts.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import ast
 import json
 import logging
+import os
 from abc import ABC, abstractmethod
 
 from typing_extensions import Optional, TYPE_CHECKING, List
@@ -10,6 +12,8 @@ from .datastructures.callable_expression import CallableExpression
 from .datastructures.enums import PromptFor
 from .datastructures.dataclasses import CaseQuery
 from .datastructures.case import show_current_and_corner_cases
+from .utils import extract_imports, extract_function_source, get_imports_from_scope, encapsulate_user_input
+
 try:
     from .user_interface.gui import RDRCaseViewer
 except ImportError as e:
@@ -36,10 +40,19 @@ class Expert(ABC):
     A flag to indicate if the expert should use loaded answers or not.
     """
 
-    def __init__(self, use_loaded_answers: bool = False, append: bool = False):
+    def __init__(self, use_loaded_answers: bool = True,
+                 append: bool = False,
+                 answers_save_path: Optional[str] = None):
         self.all_expert_answers = []
         self.use_loaded_answers = use_loaded_answers
         self.append = append
+        self.answers_save_path = answers_save_path
+        if answers_save_path is not None:
+            if use_loaded_answers:
+                self.load_answers(answers_save_path)
+            else:
+                os.remove(answers_save_path + '.py')
+            self.append = True
 
     @abstractmethod
     def ask_for_conditions(self, case_query: CaseQuery, last_evaluated_rule: Optional[Rule] = None) \
@@ -63,46 +76,138 @@ class Expert(ABC):
         :return: A callable expression that can be called with a new case as an argument.
         """
 
+    def clear_answers(self, path: Optional[str] = None):
+        """
+        Clear the expert answers.
 
-class Human(Expert):
-    """
-    The Human Expert class, an expert that asks the human to provide differentiating features and conclusions.
-    """
+        :param path: The path to clear the answers from. If None, the answers will be cleared from the
+                     answers_save_path attribute.
+        """
+        if path is None and self.answers_save_path is None:
+            raise ValueError("No path provided to clear expert answers, either provide a path or set the "
+                                "answers_save_path attribute.")
+        if path is None:
+            path = self.answers_save_path
+        if os.path.exists(path + '.json'):
+            os.remove(path + '.json')
+        if os.path.exists(path + '.py'):
+            os.remove(path + '.py')
+        self.all_expert_answers = []
 
-    def __init__(self, use_loaded_answers: bool = False, append: bool = False, viewer: Optional[RDRCaseViewer] = None):
+    def save_answers(self, path: Optional[str] = None):
         """
-        Initialize the Human expert.
+        Save the expert answers to a file.
 
-        :param viewer: The RDRCaseViewer instance to use for prompting the user.
+        :param path: The path to save the answers to.
         """
-        super().__init__(use_loaded_answers=use_loaded_answers, append=append)
-        self.user_prompt = UserPrompt(viewer)
+        if path is None and self.answers_save_path is None:
+            raise ValueError("No path provided to save expert answers, either provide a path or set the "
+                                "answers_save_path attribute.")
+        if path is None:
+            path = self.answers_save_path
+        is_json = os.path.exists(path + '.json')
+        if is_json:
+            self._save_to_json(path)
+        else:
+            self._save_to_python(path)
 
-    def save_answers(self, path: str):
+    def _save_to_json(self, path: str):
         """
-        Save the expert answers to a file.
+        Save the expert answers to a JSON file.
 
         :param path: The path to save the answers to.
         """
-        if self.append:
+        all_answers = self.all_expert_answers
+        if self.append and os.path.exists(path + '.json'):
             # read the file and append the new answers
             with open(path + '.json', "r") as f:
-                all_answers = json.load(f)
-                all_answers.extend(self.all_expert_answers)
-            with open(path + '.json', "w") as f:
-                json.dump(all_answers, f)
-        else:
-            with open(path + '.json', "w") as f:
-                json.dump(self.all_expert_answers, f)
+                old_answers = json.load(f)
+                all_answers = old_answers + all_answers
+        with open(path + '.json', "w") as f:
+            json.dump(all_answers, f)
 
-    def load_answers(self, path: str):
+    def _save_to_python(self, path: str):
+        """
+        Save the expert answers to a Python file.
+
+        :param path: The path to save the answers to.
+        """
+        dir_name = os.path.dirname(path)
+        if not os.path.exists(dir_name + '/__init__.py'):
+            os.makedirs(dir_name, exist_ok=True)
+            with open(dir_name + '/__init__.py', 'w') as f:
+                f.write('# This is an empty init file to make the directory a package.\n')
+        action = 'w' if not self.append else 'a'
+        with open(path + '.py', action) as f:
+            for scope, func_source in self.all_expert_answers:
+                if len(scope) > 0:
+                    imports = '\n'.join(get_imports_from_scope(scope)) + '\n\n\n'
+                else:
+                    imports = ''
+                if func_source is not None:
+                    func_source = encapsulate_user_input(func_source, CallableExpression.encapsulating_function)
+                else:
+                    func_source = 'pass  # No user input provided for this case.\n'
+                f.write(imports + func_source + '\n' + '\n\n\n\'===New Answer===\'\n\n\n')
+
+    def load_answers(self, path: Optional[str] = None):
         """
         Load the expert answers from a file.
 
+        :param path: The path to load the answers from.
+        """
+        if path is None and self.answers_save_path is None:
+            raise ValueError("No path provided to load expert answers from, either provide a path or set the "
+                                "answers_save_path attribute.")
+        if path is None:
+            path = self.answers_save_path
+        is_json = os.path.exists(path + '.json')
+        if is_json:
+            self._load_answers_from_json(path)
+        elif os.path.exists(path + '.py'):
+            self._load_answers_from_python(path)
+
+    def _load_answers_from_json(self, path: str):
+        """
+        Load the expert answers from a JSON file.
+
         :param path: The path to load the answers from.
         """
         with open(path + '.json', "r") as f:
-            self.all_expert_answers = json.load(f)
+            all_answers = json.load(f)
+        self.all_expert_answers = [({}, answer) for answer in all_answers]
+
+    def _load_answers_from_python(self, path: str):
+        """
+        Load the expert answers from a Python file.
+
+        :param path: The path to load the answers from.
+        """
+        file_path = path + '.py'
+        with open(file_path, "r") as f:
+            all_answers = f.read().split('\n\n\n\'===New Answer===\'\n\n\n')
+        for answer in all_answers:
+            answer = answer.strip('\n').strip()
+            if 'def ' not in answer and 'pass' in answer:
+                self.all_expert_answers.append(({}, None))
+            scope = extract_imports(tree=ast.parse(answer))
+            func_source = list(extract_function_source(file_path, []).values())[0]
+            self.all_expert_answers.append((scope, func_source))
+
+
+class Human(Expert):
+    """
+    The Human Expert class, an expert that asks the human to provide differentiating features and conclusions.
+    """
+
+    def __init__(self, viewer: Optional[RDRCaseViewer] = None, **kwargs):
+        """
+        Initialize the Human expert.
+
+        :param viewer: The RDRCaseViewer instance to use for prompting the user.
+        """
+        super().__init__(**kwargs)
+        self.user_prompt = UserPrompt(viewer)
 
     def ask_for_conditions(self, case_query: CaseQuery,
                            last_evaluated_rule: Optional[Rule] = None) \
@@ -125,13 +230,18 @@ class Human(Expert):
         if self.use_loaded_answers and len(self.all_expert_answers) == 0 and self.append:
             self.use_loaded_answers = False
         if self.use_loaded_answers:
-            user_input = self.all_expert_answers.pop(0)
-        if user_input:
+            try:
+                loaded_scope, user_input = self.all_expert_answers.pop(0)
+            except IndexError:
+                self.use_loaded_answers = False
+        if user_input is not None:
             condition = CallableExpression(user_input, bool, scope=case_query.scope)
         else:
             user_input, condition = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conditions)
         if not self.use_loaded_answers:
-            self.all_expert_answers.append(user_input)
+            self.all_expert_answers.append((condition.scope, user_input))
+            if self.answers_save_path is not None:
+                self.save_answers()
         case_query.conditions = condition
         return condition
 
@@ -143,18 +253,65 @@ class Human(Expert):
         :return: The conclusion for the case as a callable expression.
         """
         expression: Optional[CallableExpression] = None
+        expert_input: Optional[str] = None
         if self.use_loaded_answers and len(self.all_expert_answers) == 0 and self.append:
             self.use_loaded_answers = False
         if self.use_loaded_answers:
-            expert_input = self.all_expert_answers.pop(0)
-            if expert_input is not None:
-                expression = CallableExpression(expert_input, case_query.attribute_type,
-                                                scope=case_query.scope,
-                                                 mutually_exclusive=case_query.mutually_exclusive)
-        else:
+            try:
+                loaded_scope, expert_input = self.all_expert_answers.pop(0)
+                if expert_input is not None:
+                    expression = CallableExpression(expert_input, case_query.attribute_type,
+                                                    scope=case_query.scope,
+                                                    mutually_exclusive=case_query.mutually_exclusive)
+            except IndexError:
+                self.use_loaded_answers = False
+        if not self.use_loaded_answers:
             if self.user_prompt.viewer is None:
                 show_current_and_corner_cases(case_query.case)
             expert_input, expression = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conclusion)
-            self.all_expert_answers.append(expert_input)
+            if expression is None:
+                self.all_expert_answers.append(({}, None))
+            else:
+                self.all_expert_answers.append((expression.scope, expert_input))
+            if self.answers_save_path is not None:
+                self.save_answers()
         case_query.target = expression
         return expression
+
+
+class File(Expert):
+    """
+    The File Expert class, an expert that reads the answers from a file.
+    This is used for testing purposes.
+    """
+
+    def __init__(self, filename: str, **kwargs):
+        """
+        Initialize the File expert.
+
+        :param filename: The path to the file containing the expert answers.
+        """
+        super().__init__(**kwargs)
+        self.filename = filename
+        self.load_answers(filename)
+
+    def ask_for_conditions(self, case_query: CaseQuery,
+                           last_evaluated_rule: Optional[Rule] = None) -> CallableExpression:
+        loaded_scope, user_input = self.all_expert_answers.pop(0)
+        if user_input:
+            condition = CallableExpression(user_input, bool, scope=case_query.scope)
+        else:
+            raise ValueError("No user input found in the expert answers file.")
+        case_query.conditions = condition
+        return condition
+
+    def ask_for_conclusion(self, case_query: CaseQuery) -> Optional[CallableExpression]:
+        loaded_scope, expert_input = self.all_expert_answers.pop(0)
+        if expert_input is not None:
+            expression = CallableExpression(expert_input, case_query.attribute_type,
+                                            scope=case_query.scope,
+                                            mutually_exclusive=case_query.mutually_exclusive)
+        else:
+            raise ValueError("No expert input found in the expert answers file.")
+        case_query.target = expression
+        return expression

ripple_down_rules/rdr.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import copyreg
 import importlib
-import logging
+import os
+
+from . import logger
 import sys
 from abc import ABC, abstractmethod
 from copy import copy
@@ -13,7 +15,7 @@ try:
     from matplotlib import pyplot as plt
     Figure = plt.Figure
 except ImportError as e:
-    logging.debug(f"{e}: matplotlib is not installed")
+    logger.debug(f"{e}: matplotlib is not installed")
     matplotlib = None
     Figure = None
     plt = None
@@ -34,7 +36,8 @@ except ImportError as e:
     RDRCaseViewer = None
 from .utils import draw_tree, make_set, copy_case, \
     SubclassJSONSerializer, make_list, get_type_from_string, \
-    is_conflicting, update_case, get_imports_from_scope, extract_function_source, extract_imports, get_full_class_name
+    is_conflicting, update_case, get_imports_from_scope, extract_function_source, extract_imports, get_full_class_name, \
+    is_iterable, str_to_snake_case
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -61,17 +64,90 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     """
     The type of the case (input) to the RDR classifier.
     """
+    case_name: Optional[str] = None
+    """
+    The name of the case type.
+    """
+    metadata_folder: str = "rdr_metadata"
+    """
+    The folder to save the metadata of the RDR classifier.
+    """
+    model_name: Optional[str] = None
+    """
+    The name of the model. If None, the model name will be the generated python file name.
+    """
 
-    def __init__(self, start_rule: Optional[Rule] = None, viewer: Optional[RDRCaseViewer] = None):
+    def __init__(self, start_rule: Optional[Rule] = None, viewer: Optional[RDRCaseViewer] = None,
+                 save_dir: Optional[str] = None, ask_always: bool = True, model_name: Optional[str] = None):
         """
         :param start_rule: The starting rule for the classifier.
+        :param viewer: The viewer gui to use for the classifier. If None, no viewer is used.
+        :param save_dir: The directory to save the classifier to.
+        :param ask_always: Whether to always ask the expert (True) or only ask when classification fails (False).
         """
+        self.ask_always: bool = ask_always
+        self.model_name: Optional[str] = model_name
+        self.save_dir = save_dir
         self.start_rule = start_rule
         self.fig: Optional[Figure] = None
         self.viewer: Optional[RDRCaseViewer] = viewer
         if self.viewer is not None:
             self.viewer.set_save_function(self.save)
 
+    def save(self, save_dir: Optional[str] = None, model_name: Optional[str] = None) -> str:
+        """
+        Save the classifier to a file.
+
+        :param save_dir: The directory to save the classifier to.
+        :param model_name: The name of the model to save. If None, a default name is generated.
+        :param postfix: The postfix to add to the file name.
+        :return: The name of the saved model.
+        """
+        save_dir = save_dir or self.save_dir
+        if save_dir is None:
+            raise ValueError("The save directory cannot be None. Please provide a valid directory to save"
+                             " the classifier.")
+        if not os.path.exists(save_dir + '/__init__.py'):
+            os.makedirs(save_dir, exist_ok=True)
+            with open(save_dir + '/__init__.py', 'w') as f:
+                f.write("# This is an empty __init__.py file to make the directory a package.\n")
+        if model_name is not None:
+            self.model_name = model_name
+        elif self.model_name is None:
+            self.model_name = self.generated_python_file_name
+        model_dir = os.path.join(save_dir, self.model_name)
+        os.makedirs(model_dir, exist_ok=True)
+        json_dir = os.path.join(model_dir, self.metadata_folder)
+        os.makedirs(json_dir, exist_ok=True)
+        self.to_json_file(os.path.join(json_dir, self.model_name))
+        self._write_to_python(model_dir)
+        return self.model_name
+
+    @classmethod
+    def load(cls, load_dir: str, model_name: str) -> Self:
+        """
+        Load the classifier from a file.
+
+        :param load_dir: The path to the model directory to load the classifier from.
+        :param model_name: The name of the model to load.
+        """
+        model_dir = os.path.join(load_dir, model_name)
+        json_file = os.path.join(model_dir, cls.metadata_folder, model_name)
+        rdr = cls.from_json_file(json_file)
+        rdr.update_from_python(model_dir)
+        rdr.save_dir = load_dir
+        rdr.model_name = model_name
+        return rdr
+
+    @abstractmethod
+    def _write_to_python(self, model_dir: str):
+        """
+        Write the tree of rules as source code to a file.
+
+        :param model_dir: The path to the directory to write the source code to.
+        """
+        pass
+
     def set_viewer(self, viewer: RDRCaseViewer):
         """
         Set the viewer for the classifier.
@@ -122,13 +198,13 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             all_predictions = [1 if is_matching(self.classify, case_query) else 0 for case_query in case_queries
                                if case_query.target is not None]
             all_pred = sum(all_predictions)
-            print(f"Accuracy: {all_pred}/{len(targets)}")
+            logger.info(f"Accuracy: {all_pred}/{len(targets)}")
             all_predicted = targets and all_pred == len(targets)
             num_iter_reached = n_iter and i >= n_iter
             stop_iterating = all_predicted or num_iter_reached
             if stop_iterating:
                 break
-        print(f"Finished training in {i} iterations")
+        logger.info(f"Finished training in {i} iterations")
         if animate_tree:
             plt.ioff()
             plt.show()
@@ -160,19 +236,29 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         """
         if case_query is None:
             raise ValueError("The case query cannot be None.")
+
         self.name = case_query.attribute_name if self.name is None else self.name
         self.case_type = case_query.case_type if self.case_type is None else self.case_type
+        self.case_name = case_query.case_name if self.case_name is None else self.case_name
+
         if case_query.target is None:
             case_query_cp = copy(case_query)
-            self.classify(case_query_cp.case, modify_case=True)
-            expert.ask_for_conclusion(case_query_cp)
-            case_query.target = case_query_cp.target
+            conclusions = self.classify(case_query_cp.case, modify_case=True)
+            if self.ask_always or conclusions is None or is_iterable(conclusions) and len(conclusions) == 0:
+                expert.ask_for_conclusion(case_query_cp)
+                case_query.target = case_query_cp.target
             if case_query.target is None:
                 return self.classify(case_query.case)
 
         self.update_start_rule(case_query, expert)
 
-        return self._fit_case(case_query, expert=expert, **kwargs)
+        fit_case_result = self._fit_case(case_query, expert=expert, **kwargs)
+
+        if self.save_dir is not None:
+            self.save()
+            expert.clear_answers()
+
+        return fit_case_result
 
     @abstractmethod
     def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
@@ -238,28 +324,54 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         pass
 
     @abstractmethod
-    def update_from_python_file(self, package_dir: str):
+    def update_from_python(self, model_dir: str):
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
-        :param package_dir: The directory of the package that contains the generated python file.
+        :param model_dir: The directory where the generated python file is located.
         """
         pass
 
+    @classmethod
+    def get_acronym(cls) -> str:
+        """
+        :return: The acronym of the classifier.
+        """
+        if cls.__name__ == "GeneralRDR":
+            return "RDR"
+        elif cls.__name__ == "MultiClassRDR":
+            return "MCRDR"
+        else:
+            return "SCRDR"
+
+    def get_rdr_classifier_from_python_file(self, package_name: str) -> Callable[[Any], Any]:
+        """
+        :param package_name: The name of the package that contains the RDR classifier function.
+        :return: The module that contains the rdr classifier function.
+        """
+        # remove from imports if exists first
+        name = f"{package_name.strip('./').replace('/', '.')}.{self.generated_python_file_name}"
+        try:
+            module = importlib.import_module(name)
+            del sys.modules[name]
+        except ModuleNotFoundError:
+            pass
+        return importlib.import_module(name).classify
+
 
 class RDRWithCodeWriter(RippleDownRules, ABC):
 
-    def update_from_python_file(self, package_dir: str):
+    def update_from_python(self, model_dir: str):
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
-        :param package_dir: The directory of the package that contains the generated python file.
+        :param model_dir: The directory where the generated python file is located.
         """
-        rule_ids = [r.uid for r in [self.start_rule] + list(self.start_rule.descendants) if r.conditions is not None]
-        condition_func_names = [f'conditions_{rid}' for rid in rule_ids]
-        conclusion_func_names = [f'conclusion_{rid}' for rid in rule_ids]
+        rules_dict = {r.uid: r for r in [self.start_rule] + list(self.start_rule.descendants) if r.conditions is not None}
+        condition_func_names = [f'conditions_{rid}' for rid in rules_dict.keys()]
+        conclusion_func_names = [f'conclusion_{rid}' for rid in rules_dict.keys() if not isinstance(rules_dict[rid], MultiClassStopRule)]
         all_func_names = condition_func_names + conclusion_func_names
-        filepath = f"{package_dir}/{self.generated_python_defs_file_name}.py"
+        filepath = f"{model_dir}/{self.generated_python_defs_file_name}.py"
         functions_source = extract_function_source(filepath, all_func_names, include_signature=False)
         # get the scope from the imports in the file
         scope = extract_imports(filepath)
@@ -267,7 +379,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             if rule.conditions is not None:
                 rule.conditions.user_input = functions_source[f"conditions_{rule.uid}"]
                 rule.conditions.scope = scope
-            if rule.conclusion is not None:
+            if rule.conclusion is not None and not isinstance(rule, MultiClassStopRule):
                 rule.conclusion.user_input = functions_source[f"conclusion_{rule.uid}"]
                 rule.conclusion.scope = scope
 
@@ -284,17 +396,19 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         pass
 
-    def write_to_python_file(self, file_path: str, postfix: str = ""):
+    def _write_to_python(self, model_dir: str):
         """
         Write the tree of rules as source code to a file.
 
-        :param file_path: The path to the file to write the source code to.
-        :param postfix: The postfix to add to the file name.
+        :param model_dir: The path to the directory to write the source code to.
         """
-        self.generated_python_file_name = self._default_generated_python_file_name + postfix
+        os.makedirs(model_dir, exist_ok=True)
+        if not os.path.exists(model_dir + '/__init__.py'):
+            with open(model_dir + '/__init__.py', 'w') as f:
+                f.write("# This is an empty __init__.py file to make the directory a package.\n")
         func_def = f"def classify(case: {self.case_type.__name__}) -> {self.conclusion_type_hint}:\n"
-        file_name = file_path + f"/{self.generated_python_file_name}.py"
-        defs_file_name = file_path + f"/{self.generated_python_defs_file_name}.py"
+        file_name = model_dir + f"/{self.generated_python_file_name}.py"
+        defs_file_name = model_dir + f"/{self.generated_python_defs_file_name}.py"
         imports, defs_imports = self._get_imports()
         # clear the files first
         with open(defs_file_name, "w") as f:
@@ -345,20 +459,6 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         imports = "\n".join(imports) + "\n"
         return imports, defs_imports
 
-    def get_rdr_classifier_from_python_file(self, package_name: str) -> Callable[[Any], Any]:
-        """
-        :param package_name: The name of the package that contains the RDR classifier function.
-        :return: The module that contains the rdr classifier function.
-        """
-        # remove from imports if exists first
-        name = f"{package_name.strip('./')}.{self.generated_python_file_name}"
-        try:
-            module = importlib.import_module(name)
-            del sys.modules[name]
-        except ModuleNotFoundError:
-            pass
-        return importlib.import_module(name).classify
-
     @property
     def _default_generated_python_file_name(self) -> Optional[str]:
         """
@@ -366,23 +466,12 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         if self.start_rule is None or self.start_rule.conclusion is None:
             return None
-        return f"{self.case_type.__name__.lower()}_{self.attribute_name}_{self.acronym.lower()}"
+        return f"{str_to_snake_case(self.case_name)}_{self.attribute_name}_{self.get_acronym().lower()}"
 
     @property
     def generated_python_defs_file_name(self) -> str:
         return f"{self.generated_python_file_name}_defs"
 
-    @property
-    def acronym(self) -> str:
-        """
-        :return: The acronym of the classifier.
-        """
-        if self.__class__.__name__ == "GeneralRDR":
-            return "GRDR"
-        elif self.__class__.__name__ == "MultiClassRDR":
-            return "MCRDR"
-        else:
-            return "SCRDR"
 
     @property
     def conclusion_type(self) -> Tuple[Type]:
@@ -403,7 +492,9 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
 
     def _to_json(self) -> Dict[str, Any]:
         return {"start_rule": self.start_rule.to_json(),  "generated_python_file_name": self.generated_python_file_name,
-                "name": self.name, "case_type": get_full_class_name(self.case_type) if self.case_type is not None else None}
+                "name": self.name,
+                "case_type": get_full_class_name(self.case_type) if self.case_type is not None else None,
+                "case_name": self.case_name}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Self:
@@ -411,13 +502,15 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         Create an instance of the class from a json
         """
         start_rule = cls.start_rule_type().from_json(data["start_rule"])
-        new_rdr = cls(start_rule)
+        new_rdr = cls(start_rule=start_rule)
         if "generated_python_file_name" in data:
             new_rdr.generated_python_file_name = data["generated_python_file_name"]
         if "name" in data:
             new_rdr.name = data["name"]
         if "case_type" in data:
             new_rdr.case_type = get_type_from_string(data["case_type"])
+        if "case_name" in data:
+            new_rdr.case_name = data["case_name"]
         return new_rdr
 
     @staticmethod
@@ -431,12 +524,12 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
 
 class SingleClassRDR(RDRWithCodeWriter):
 
-    def __init__(self, start_rule: Optional[SingleClassRule] = None, default_conclusion: Optional[Any] = None):
+    def __init__(self, default_conclusion: Optional[Any] = None, **kwargs):
         """
         :param start_rule: The starting rule for the classifier.
         :param default_conclusion: The default conclusion for the classifier if no rules fire.
         """
-        super(SingleClassRDR, self).__init__(start_rule)
+        super(SingleClassRDR, self).__init__(**kwargs)
         self.default_conclusion: Optional[Any] = default_conclusion
 
     def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
@@ -488,10 +581,10 @@ class SingleClassRDR(RDRWithCodeWriter):
         matched_rule = self.start_rule(case) if self.start_rule is not None else None
         return matched_rule if matched_rule is not None else self.start_rule
 
-    def write_to_python_file(self, file_path: str, postfix: str = ""):
-        super().write_to_python_file(file_path, postfix)
+    def _write_to_python(self, model_dir: str):
+        super()._write_to_python(model_dir)
         if self.default_conclusion is not None:
-            with open(file_path + f"/{self.generated_python_file_name}.py", "a") as f:
+            with open(model_dir + f"/{self.generated_python_file_name}.py", "a") as f:
                 f.write(f"{' ' * 4}else:\n{' ' * 8}return {self.default_conclusion}\n")
 
     def write_rules_as_source_code_to_file(self, rule: SingleClassRule, file: TextIOWrapper, parent_indent: str = "",
@@ -892,7 +985,8 @@ class GeneralRDR(RippleDownRules):
         return {"start_rules": {name: rdr.to_json() for name, rdr in self.start_rules_dict.items()}
                 , "generated_python_file_name": self.generated_python_file_name,
                 "name": self.name,
-                "case_type": get_full_class_name(self.case_type) if self.case_type is not None else None}
+                "case_type": get_full_class_name(self.case_type) if self.case_type is not None else None,
+                "case_name": self.case_name}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> GeneralRDR:
@@ -902,37 +996,37 @@ class GeneralRDR(RippleDownRules):
         start_rules_dict = {}
         for k, v in data["start_rules"].items():
             start_rules_dict[k] = get_type_from_string(v['_type']).from_json(v)
-        new_rdr = cls(start_rules_dict)
+        new_rdr = cls(category_rdr_map=start_rules_dict)
         if "generated_python_file_name" in data:
             new_rdr.generated_python_file_name = data["generated_python_file_name"]
         if "name" in data:
             new_rdr.name = data["name"]
         if "case_type" in data:
             new_rdr.case_type = get_type_from_string(data["case_type"])
+        if "case_name" in data:
+            new_rdr.case_name = data["case_name"]
         return new_rdr
 
-    def update_from_python_file(self, package_dir: str) -> None:
+    def update_from_python(self, model_dir: str) -> None:
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
-        :param package_dir: The directory of the package that contains the generated python file.
+        :param model_dir: The directory where the model is stored.
         """
         for rdr in self.start_rules_dict.values():
-            rdr.update_from_python_file(package_dir)
+            rdr.update_from_python(model_dir)
 
-    def write_to_python_file(self, file_path: str, postfix: str = "") -> None:
+    def _write_to_python(self, model_dir: str) -> None:
         """
         Write the tree of rules as source code to a file.
 
-        :param file_path: The path to the file to write the source code to.
-        :param postfix: The postfix to add to the file name.
+        :param model_dir: The directory where the model is stored.
         """
-        self.generated_python_file_name = self._default_generated_python_file_name + postfix
         for rdr in self.start_rules_dict.values():
-            rdr.write_to_python_file(file_path, postfix=f"_of_grdr{postfix}")
+            rdr._write_to_python(model_dir)
         func_def = f"def classify(case: {self.case_type.__name__}) -> {self.conclusion_type_hint}:\n"
-        with open(file_path + f"/{self.generated_python_file_name}.py", "w") as f:
-            f.write(self._get_imports(file_path) + "\n\n")
+        with open(model_dir + f"/{self.generated_python_file_name}.py", "w") as f:
+            f.write(self._get_imports() + "\n\n")
             f.write("classifiers_dict = dict()\n")
             for rdr_key, rdr in self.start_rules_dict.items():
                 f.write(f"classifiers_dict['{rdr_key}'] = {self.rdr_key_to_function_name(rdr_key)}\n")
@@ -942,13 +1036,6 @@ class GeneralRDR(RippleDownRules):
                     f"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
             f.write(f"{' ' * 4}return GeneralRDR._classify(classifiers_dict, case)\n")
 
-    def get_rdr_classifier_from_python_file(self, file_path: str) -> Callable[[Any], Any]:
-        """
-        :param file_path: The path to the file that contains the RDR classifier function.
-        :return: The module that contains the rdr classifier function.
-        """
-        return importlib.import_module(f"{file_path.strip('./')}.{self.generated_python_file_name}").classify
-
     @property
     def _default_generated_python_file_name(self) -> Optional[str]:
         """
@@ -956,17 +1043,16 @@ class GeneralRDR(RippleDownRules):
         """
         if self.start_rule is None or self.start_rule.conclusion is None:
             return None
-        return f"{self.case_type.__name__.lower()}_rdr".lower()
+        return f"{str_to_snake_case(self.case_name)}_rdr".lower()
 
     @property
     def conclusion_type_hint(self) -> str:
         return f"Dict[str, Any]"
 
-    def _get_imports(self, file_path: str) -> str:
+    def _get_imports(self) -> str:
         """
         Get the imports needed for the generated python file.
 
-        :param file_path: The path to the file that contains the RDR classifier function.
         :return: The imports needed for the generated python file.
         """
         imports = ""

ripple_down_rules/rdr_decorators.py

@@ -5,15 +5,17 @@ of the RDRs.
 """
 import os.path
 from functools import wraps
+
+from pyparsing.tools.cvt_pyparsing_pep8_names import camel_to_snake
 from typing_extensions import Callable, Optional, Type, Tuple, Dict, Any, Self, get_type_hints, List, Union
 
-from ripple_down_rules.datastructures.case import create_case
+from ripple_down_rules.datastructures.case import create_case, Case
 from ripple_down_rules.datastructures.dataclasses import CaseQuery
 from ripple_down_rules.datastructures.enums import Category
 from ripple_down_rules.experts import Expert, Human
 from ripple_down_rules.rdr import GeneralRDR, RippleDownRules
 from ripple_down_rules.utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
-    get_method_class_if_exists
+    get_method_class_if_exists, get_method_name, str_to_snake_case
 
 
 class RDRDecorator:
@@ -41,99 +43,118 @@ class RDRDecorator:
         :return: A decorator to use a GeneralRDR as a classifier that monitors and modifies the function's output.
         """
         self.rdr_models_dir = models_dir
+        self.model_name: Optional[str] = None
         self.output_type = output_type
         self.parsed_output_type: List[Type] = []
         self.mutual_exclusive = mutual_exclusive
         self.rdr_python_path: Optional[str] = python_dir
         self.output_name = output_name
         self.fit: bool = fit
-        self.expert = expert if expert else Human()
-        self.rdr_model_path: Optional[str] = None
+        self.expert: Optional[Expert] = expert
         self.load()
 
     def decorator(self, func: Callable) -> Callable:
 
         @wraps(func)
         def wrapper(*args, **kwargs) -> Optional[Any]:
+
             if len(self.parsed_output_type) == 0:
-                self.parse_output_type(func, *args)
-            if self.rdr_model_path is None:
-                self.initialize_rdr_model_path_and_load(func)
-            case_dict = get_method_args_as_dict(func, *args, **kwargs)
-            func_output = func(*args, **kwargs)
-            case_dict.update({self.output_name: func_output})
-            case = create_case(case_dict, obj_name=get_func_rdr_model_name(func), max_recursion_idx=3)
+                self.parsed_output_type = self.parse_output_type(func, self.output_type, *args)
+            if self.model_name is None:
+                self.initialize_rdr_model_name_and_load(func)
+
             if self.fit:
-                scope = func.__globals__
-                scope.update(case_dict)
-                func_args_type_hints = get_type_hints(func)
-                func_args_type_hints.update({self.output_name: Union[tuple(self.parsed_output_type)]})
-                case_query = CaseQuery(case, self.output_name, Union[tuple(self.parsed_output_type)],
-                                       self.mutual_exclusive,
-                                       scope=scope, is_function=True, function_args_type_hints=func_args_type_hints)
+                expert_answers_path = os.path.join(self.rdr_models_dir, self.model_name, "expert_answers")
+                self.expert = self.expert or Human(answers_save_path=expert_answers_path)
+                case_query = self.create_case_query_from_method(func, self.parsed_output_type,
+                                                                self.mutual_exclusive, self.output_name,
+                                                                *args, **kwargs)
                 output = self.rdr.fit_case(case_query, expert=self.expert)
                 return output[self.output_name]
             else:
+                case, case_dict = self.create_case_from_method(func, self.output_name, *args, **kwargs)
                 return self.rdr.classify(case)[self.output_name]
 
         return wrapper
 
-    def initialize_rdr_model_path_and_load(self, func: Callable) -> None:
+    @staticmethod
+    def create_case_query_from_method(func: Callable, output_type, mutual_exclusive: bool,
+                                output_name: str = 'output_', *args, **kwargs) -> CaseQuery:
+        """
+        Create a CaseQuery from the function and its arguments.
+
+        :param func: The function to create a case from.
+        :param output_type: The type of the output.
+        :param mutual_exclusive: If True, the output types are mutually exclusive.
+        :param output_name: The name of the output in the case. Defaults to 'output_'.
+        :param args: The positional arguments of the function.
+        :param kwargs: The keyword arguments of the function.
+        :return: A CaseQuery object representing the case.
+        """
+        output_type = make_set(output_type)
+        case, case_dict = RDRDecorator.create_case_from_method(func, output_name, *args, **kwargs)
+        scope = func.__globals__
+        scope.update(case_dict)
+        func_args_type_hints = get_type_hints(func)
+        func_args_type_hints.update({output_name: Union[tuple(output_type)]})
+        return CaseQuery(case, output_name, Union[tuple(output_type)],
+                         mutual_exclusive, scope=scope,
+                         is_function=True, function_args_type_hints=func_args_type_hints)
+
+    @staticmethod
+    def create_case_from_method(func: Callable, output_name: str = "output_", *args, **kwargs) -> Tuple[Case, Dict[str, Any]]:
+        """
+        Create a Case from the function and its arguments.
+
+        :param func: The function to create a case from.
+        :param output_name: The name of the output in the case. Defaults to 'output_'.
+        :param args: The positional arguments of the function.
+        :param kwargs: The keyword arguments of the function.
+        :return: A Case object representing the case.
+        """
+        case_dict = get_method_args_as_dict(func, *args, **kwargs)
+        func_output = func(*args, **kwargs)
+        case_dict.update({output_name: func_output})
+        case_name = get_func_rdr_model_name(func)
+        return create_case(case_dict, obj_name=case_name, max_recursion_idx=3), case_dict
+
+    def initialize_rdr_model_name_and_load(self, func: Callable) -> None:
         model_file_name = get_func_rdr_model_name(func, include_file_name=True)
-        model_file_name = (''.join(['_' + c.lower() if c.isupper() else c for c in model_file_name]).lstrip('_')
-                           .replace('__', '_') + ".json")
-        self.rdr_model_path = os.path.join(self.rdr_models_dir, model_file_name)
+        self.model_name = str_to_snake_case(model_file_name)
         self.load()
 
-    def parse_output_type(self, func: Callable, *args) -> None:
-        for ot in make_set(self.output_type):
+    @staticmethod
+    def parse_output_type(func: Callable, output_type: Any, *args) -> List[Type]:
+        parsed_output_type = []
+        for ot in make_set(output_type):
             if ot is Self:
                 func_class = get_method_class_if_exists(func, *args)
                 if func_class is not None:
-                    self.parsed_output_type.append(func_class)
+                    parsed_output_type.append(func_class)
                 else:
                     raise ValueError(f"The function {func} is not a method of a class,"
                                      f" and the output type is {Self}.")
             else:
-                self.parsed_output_type.append(ot)
+                parsed_output_type.append(ot)
+        return parsed_output_type
 
     def save(self):
         """
         Save the RDR model to the specified directory.
         """
-        self.rdr.save(self.rdr_model_path)
-
-        if self.rdr_python_path is not None:
-            if not os.path.exists(self.rdr_python_path):
-                os.makedirs(self.rdr_python_path)
-            if not os.path.exists(os.path.join(self.rdr_python_path, "__init__.py")):
-                # add __init__.py file to the directory
-                with open(os.path.join(self.rdr_python_path, "__init__.py"), "w") as f:
-                    f.write("# This is an empty __init__.py file to make the directory a package.")
-            # write the RDR model to a python file
-            self.rdr.write_to_python_file(self.rdr_python_path)
+        self.rdr.save(self.rdr_models_dir)
 
     def load(self):
         """
         Load the RDR model from the specified directory.
         """
-        if self.rdr_model_path is not None and os.path.exists(self.rdr_model_path):
-            self.rdr = GeneralRDR.load(self.rdr_model_path)
+        if self.model_name is not None and os.path.exists(os.path.join(self.rdr_models_dir, self.model_name)):
+            self.rdr = GeneralRDR.load(self.rdr_models_dir, self.model_name)
         else:
-            self.rdr = GeneralRDR()
-
-    def write_to_python_file(self, package_dir: str, file_name_postfix: str = ""):
-        """
-        Write the RDR model to a python file.
-
-        :param package_dir: The path to the directory to write the python file.
-        """
-        self.rdr.write_to_python_file(package_dir, postfix=file_name_postfix)
+            self.rdr = GeneralRDR(save_dir=self.rdr_models_dir, model_name=self.model_name)
 
-    def update_from_python_file(self, package_dir: str):
+    def update_from_python(self):
         """
         Update the RDR model from a python file.
-
-        :param package_dir: The directory of the package that contains the generated python file.
         """
-        self.rdr.update_from_python_file(package_dir)
+        self.rdr.update_from_python(self.rdr_models_dir, self.model_name)

ripple_down_rules/rules.py

@@ -118,7 +118,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             func_call = f"{parent_indent}    return {new_function_name.replace('def ', '')}(case)\n"
             return "\n".join(conclusion_lines).strip(' '), func_call
         else:
-            raise ValueError(f"Conclusion is format is not valid, it should be contain a function definition."
+            raise ValueError(f"Conclusion format is not valid, it should contain a function definition."
                              f" Instead got:\n{conclusion}\n")
 
     def write_condition_as_source_code(self, parent_indent: str = "", defs_file: Optional[str] = None) -> str:
@@ -129,9 +129,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         :param defs_file: The file to write the conditions to if they are a definition.
         """
         if_clause = self._if_statement_source_code_clause()
-        if '\n' not in self.conditions.user_input:
-            return f"{parent_indent}{if_clause} {self.conditions.user_input}:\n"
-        elif "def " in self.conditions.user_input:
+        if "def " in self.conditions.user_input:
             if defs_file is None:
                 raise ValueError("Cannot write conditions to source code as definitions python file was not given.")
             # This means the conditions are a definition that should be written and then called
@@ -143,6 +141,9 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             with open(defs_file, 'a') as f:
                 f.write(def_code.strip() + "\n\n\n")
             return f"\n{parent_indent}{if_clause} {new_function_name.replace('def ', '')}(case):\n"
+        else:
+            raise ValueError(f"Conditions format is not valid, it should contain a function definition"
+                             f" Instead got:\n{self.conditions.user_input}\n")
 
     @abstractmethod
     def _if_statement_source_code_clause(self) -> str:

ripple_down_rules/user_interface/template_file_creator.py

@@ -258,12 +258,12 @@ class TemplateFileCreator:
             func_name = f"{prompt_for.value.lower()}_for_"
         case_name = case_query.name.replace(".", "_")
         if case_query.is_function:
-            # convert any CamelCase word into snake_case by adding _ before each capital letter
-            case_name = case_name.replace(f"_{case_query.attribute_name}", "")
-        func_name += case_name
-        attribute_types = TemplateFileCreator.get_core_attribute_types(case_query)
-        attribute_type_names = [t.__name__ for t in attribute_types]
-        func_name += f"_of_type_{'_or_'.join(attribute_type_names)}"
+            func_name += case_name.replace(f"_{case_query.attribute_name}", "")
+        else:
+            func_name += case_name
+            attribute_types = TemplateFileCreator.get_core_attribute_types(case_query)
+            attribute_type_names = [t.__name__ for t in attribute_types]
+            func_name += f"_of_type_{'_or_'.join(attribute_type_names)}"
         return str_to_snake_case(func_name)
 
     @cached_property

ripple_down_rules/utils.py

@@ -178,7 +178,7 @@ def extract_function_source(file_path: str,
     functions_source: Dict[str, Union[str, List[str]]] = {}
     line_numbers = []
     for node in tree.body:
-        if isinstance(node, ast.FunctionDef) and node.name in function_names:
+        if isinstance(node, ast.FunctionDef) 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]
@@ -186,9 +186,9 @@ def extract_function_source(file_path: str,
                 func_lines = func_lines[1:]
             line_numbers.append((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):
+            if len(functions_source) >= len(function_names):
                 break
-    if len(functions_source) != len(function_names):
+    if len(functions_source) < len(function_names):
         raise ValueError(f"Could not find all functions in {file_path}: {function_names} not found,"
                          f"functions not found: {set(function_names) - set(functions_source.keys())}")
     if return_line_numbers:
@@ -953,9 +953,6 @@ class SubclassJSONSerializer:
 
         raise ValueError("Unknown type {}".format(data["_type"]))
 
-    save = to_json_file
-    load = from_json_file
-
 
 def _pickle_thread(thread_obj) -> Any:
     """Return a plain object with user-defined attributes but no thread behavior."""
@@ -1098,24 +1095,29 @@ def get_origin_and_args_from_type_hint(type_hint: Type) -> Tuple[Optional[Type],
         return origin, args
 
 
-def table_rows_as_str(row_dict: Dict[str, Any], columns_per_row: int = 9):
+def table_rows_as_str(row_dicts: List[Dict[str, Any]], columns_per_row: int = 20):
     """
     Print a table row.
 
-    :param row_dict: The row to print.
+    :param row_dicts: The rows to print.
     :param columns_per_row: The maximum number of columns per row.
     """
-    all_items = list(row_dict.items())
+    all_row_dicts_items = [list(row_dict.items()) for row_dict in row_dicts]
     # make items a list of n rows such that each row has a max size of 4
-    all_items = [all_items[i:i + columns_per_row] for i in range(0, len(all_items), columns_per_row)]
+    all_items = [all_items[i:i + columns_per_row] for all_items in all_row_dicts_items
+                 for i in range(0, len(all_items), columns_per_row)]
     keys = [list(map(lambda i: i[0], row)) for row in all_items]
     values = [list(map(lambda i: i[1], row)) for row in all_items]
+    zipped_keys = list(zip(*keys))
+    zipped_values = list(zip(*values))
+    keys_values = [list(zip(zipped_keys[i], zipped_values[i])) for i in range(len(zipped_keys))]
+    keys_values = [list(r[0]) + list(r[1]) if len(r) > 1 else r[0] for r in keys_values]
     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)
+    row_values = [list(map(lambda v: str(v) if v is not None else "", row)) for row in keys_values]
+    row_values = [list(map(lambda v: v[:150] + '...' if len(v) > 150 else v, row)) for row in row_values]
+    row_values = [list(map(lambda v: v.lower() if v in ["True", "False"] else v, row)) for row in row_values]
+    table = tabulate(row_values, tablefmt='simple_grid', maxcolwidths=[150] * 2)
+    all_table_rows.append(table)
     return "\n".join(all_table_rows)
 
 

{ripple_down_rules-0.4.86.dist-info → ripple_down_rules-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.4.86
+Version: 0.5.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
@@ -693,20 +693,12 @@ Requires-Dist: colorama
 Requires-Dist: pygments
 Requires-Dist: sqlalchemy
 Requires-Dist: pandas
+Provides-Extra: viz
+Requires-Dist: networkx>=3.1; extra == "viz"
+Requires-Dist: matplotlib>=3.7.5; extra == "viz"
 Provides-Extra: gui
 Requires-Dist: pyqt6; extra == "gui"
 Requires-Dist: qtconsole; extra == "gui"
-Provides-Extra: viz
-Requires-Dist: matplotlib; extra == "viz"
-Requires-Dist: networkx; extra == "viz"
-Provides-Extra: dev
-Requires-Dist: pyqt6; extra == "dev"
-Requires-Dist: qtconsole; extra == "dev"
-Requires-Dist: matplotlib; extra == "dev"
-Requires-Dist: networkx; extra == "dev"
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: ucimlrepo>=0.0.7; extra == "dev"
-Requires-Dist: pdbpp; extra == "dev"
 Dynamic: license-file
 
 # Ripple Down Rules (RDR)

ripple_down_rules-0.5.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+ripple_down_rules/__init__.py,sha256=FQAv_KtUXVoz9VCR37DEoK0MC84rKZnIRUy-4pQ95sE,100
+ripple_down_rules/datasets.py,sha256=fJbZ7V-UUYTu5XVVpFinTbuzN3YePCnUB01L3AyZVM8,6837
+ripple_down_rules/experts.py,sha256=9Vc3vx0uhDPy3YlNjwKuWJLl_A-kubRPUU6bMvQhaAg,13237
+ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
+ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
+ripple_down_rules/rdr.py,sha256=E1OiiZClQyAfGjL64ID-MWYFO4-h8iUAX-Vm9qrOoeQ,48727
+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=uS38KcFceRMzT_470DCL1M0LzETdP5RLwE7cCmfo7eI,51086
+ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
+ripple_down_rules/datastructures/callable_expression.py,sha256=3EucsD3jWzekhjyzL2y0dyUsucd-aqC9glmgPL0Ubb4,12425
+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.0.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.5.0.dist-info/METADATA,sha256=LYiepkd0xlfYVqVMdVrKZNbMJuxybqBheA2b0_CgGsY,43306
+ripple_down_rules-0.5.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+ripple_down_rules-0.5.0.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.5.0.dist-info/RECORD,,

ripple_down_rules-0.4.86.dist-info/RECORD

@@ -1,26 +0,0 @@
-ripple_down_rules/__init__.py,sha256=v-1F6x1Q2QlDiOWgzsCkkSZVyHAeRboirfjTWeRqJxo,22
-ripple_down_rules/datasets.py,sha256=fJbZ7V-UUYTu5XVVpFinTbuzN3YePCnUB01L3AyZVM8,6837
-ripple_down_rules/experts.py,sha256=RWDR-xxbeFIrUQiMYLEDr_PLQFdpPZ-hOXo4dpeiUpI,6630
-ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
-ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
-ripple_down_rules/rdr.py,sha256=zQiWHUw8Qq-FPuKHdBErZUhh8zqiB6UCBi1kWZx5cJE,45511
-ripple_down_rules/rdr_decorators.py,sha256=VdmE0JrE8j89b6Af1R1tLZiKfy3h1VCvhAUefN_FLLQ,6753
-ripple_down_rules/rules.py,sha256=7NB8qWW7XEB45tmJRYsKJqBG8DN3v02fzAFYmOkX8ow,17458
-ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=iM2bYRYanuWTnq7dflRar8tMwRxL88B__hWkayGLVz4,50675
-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=3nGeTv9JYpnRSmsHCt61qo1QT4d9Dfkl9KrZ7I6E2kk,15164
-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=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=J_bBOJltc1fsrIYeHdrSUA_jep2DhDbTK5NYRbL6QyY,13831
-ripple_down_rules-0.4.86.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.4.86.dist-info/METADATA,sha256=OZ1QS5AnJFolHEoUSn_b88yB7jX2SN3Kanyr6u_Y9oY,43598
-ripple_down_rules-0.4.86.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-ripple_down_rules-0.4.86.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.4.86.dist-info/RECORD,,