ripple-down-rules 0.4.7__py3-none-any.whl → 0.4.9__py3-none-any.whl

ripple_down_rules/rdr.py

@@ -2,13 +2,24 @@ from __future__ import annotations
 
 import copyreg
 import importlib
+import os
+
+from . import logger
 import sys
 from abc import ABC, abstractmethod
 from copy import copy
 from io import TextIOWrapper
 from types import ModuleType
 
-from matplotlib import pyplot as plt
+try:
+    from matplotlib import pyplot as plt
+    Figure = plt.Figure
+except ImportError as e:
+    logger.debug(f"{e}: matplotlib is not installed")
+    matplotlib = None
+    Figure = None
+    plt = None
+
 from sqlalchemy.orm import DeclarativeBase as SQLTable
 from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tuple, Callable, Set
 
@@ -19,17 +30,21 @@ from .datastructures.enums import MCRDRMode
 from .experts import Expert, Human
 from .helpers import is_matching
 from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
-from .user_interface.gui import RDRCaseViewer
+try:
+    from .user_interface.gui import RDRCaseViewer
+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
+    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):
     """
     The abstract base class for the ripple down rules classifiers.
     """
-    fig: Optional[plt.Figure] = None
+    fig: Optional[Figure] = None
     """
     The figure to draw the tree on.
     """
@@ -45,17 +60,94 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     """
     The name of the classifier.
     """
+    case_type: Optional[Type] = None
+    """
+    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[plt.Figure] = None
+        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.
@@ -82,6 +174,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         """
         targets = []
         if animate_tree:
+            if plt is None:
+                raise ImportError("matplotlib is not installed, cannot animate the tree.")
             plt.ion()
         i = 0
         stop_iterating = False
@@ -104,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()
@@ -142,18 +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) \
@@ -219,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)
@@ -248,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
 
@@ -265,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:
@@ -326,56 +459,19 @@ 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) -> str:
+    def _default_generated_python_file_name(self) -> Optional[str]:
         """
         :return: The default generated python file name.
         """
-        if isinstance(self.start_rule.corner_case, Case):
-            name = self.start_rule.corner_case._name
-        else:
-            name = self.start_rule.corner_case.__class__.__name__
-        return f"{name.lower()}_{self.attribute_name}_{self.acronym.lower()}"
+        if self.start_rule is None or self.start_rule.conclusion is None:
+            return None
+        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 case_type(self) -> Type:
-        """
-        :return: The type of the case (input) to the RDR classifier.
-        """
-        if isinstance(self.start_rule.corner_case, Case):
-            return self.start_rule.corner_case._obj_type
-        else:
-            return type(self.start_rule.corner_case)
 
     @property
     def conclusion_type(self) -> Tuple[Type]:
@@ -396,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}
+                "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:
@@ -404,11 +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
@@ -422,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) \
@@ -479,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 = "",
@@ -758,7 +860,7 @@ class GeneralRDR(RippleDownRules):
         self.start_rules_dict: Dict[str, Union[SingleClassRDR, MultiClassRDR]] \
             = category_rdr_map if category_rdr_map else {}
         super(GeneralRDR, self).__init__(**kwargs)
-        self.all_figs: List[plt.Figure] = [sr.fig for sr in self.start_rules_dict.values()]
+        self.all_figs: List[Figure] = [sr.fig for sr in self.start_rules_dict.values()]
 
     def add_rdr(self, rdr: Union[SingleClassRDR, MultiClassRDR], case_query: Optional[CaseQuery] = None):
         """
@@ -882,7 +984,9 @@ class GeneralRDR(RippleDownRules):
     def _to_json(self) -> Dict[str, Any]:
         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}
+                "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]) -> GeneralRDR:
@@ -892,35 +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")
@@ -930,25 +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")
 
-    @property
-    def case_type(self) -> Optional[Type]:
-        """
-        :return: The type of the case (input) to the RDR classifier.
-        """
-        if self.start_rule is None or self.start_rule.corner_case is None:
-            return None
-        if isinstance(self.start_rule.corner_case, Case):
-            return self.start_rule.corner_case._obj_type
-        else:
-            return type(self.start_rule.corner_case)
-
-    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,21 +1043,16 @@ class GeneralRDR(RippleDownRules):
         """
         if self.start_rule is None or self.start_rule.conclusion is None:
             return None
-        if isinstance(self.start_rule.corner_case, Case):
-            name = self.start_rule.corner_case._name
-        else:
-            name = self.start_rule.corner_case.__class__.__name__
-        return f"{name}_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 = ""