ripple-down-rules 0.6.0__py3-none-any.whl → 0.6.6__py3-none-any.whl

ripple_down_rules/rdr.py

@@ -1,17 +1,24 @@
 from __future__ import annotations
 
+import ast
 import importlib
+import json
 import os
+import sys
 from abc import ABC, abstractmethod
 from copy import copy
-from types import NoneType
+from dataclasses import is_dataclass
+from io import TextIOWrapper
+from os.path import dirname
+from pathlib import Path
+from types import NoneType, ModuleType
 
 from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
 from . import logger
+from .failures import RDRLoadError
 
 try:
     from matplotlib import pyplot as plt
-
     Figure = plt.Figure
 except ImportError as e:
     logger.debug(f"{e}: matplotlib is not installed")
@@ -25,18 +32,22 @@ from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tupl
 from .datastructures.callable_expression import CallableExpression
 from .datastructures.case import Case, CaseAttribute, create_case
 from .datastructures.dataclasses import CaseQuery
-from .datastructures.enums import MCRDRMode
+from .datastructures.enums import MCRDRMode, RDREdge
 from .experts import Expert, Human
-from .helpers import is_matching, general_rdr_classify
-from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
+from .helpers import is_matching, general_rdr_classify, get_an_updated_case_copy
+from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule, MultiClassRefinementRule, \
+    MultiClassFilterRule
 
 try:
     from .user_interface.gui import RDRCaseViewer
 except ImportError as e:
     RDRCaseViewer = None
 from .utils import draw_tree, make_set, SubclassJSONSerializer, make_list, get_type_from_string, \
-    is_conflicting, extract_function_source, extract_imports, get_full_class_name, \
-    is_iterable, str_to_snake_case, get_import_path_from_path, get_imports_from_types
+    is_value_conflicting, extract_function_source, extract_imports, get_full_class_name, \
+    is_iterable, str_to_snake_case, get_import_path_from_path, get_imports_from_types, render_tree, \
+    get_types_to_import_from_func_type_hints, get_function_return_type, get_file_that_ends_with, \
+    get_and_import_python_module, get_and_import_python_modules_in_a_package, get_type_from_type_hint, \
+    are_results_subclass_of_types
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -80,20 +91,98 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     Whether the output of the classification of this rdr allows only one possible conclusion or not.
     """
 
-    def __init__(self, start_rule: Optional[Rule] = None, viewer: Optional[RDRCaseViewer] = None,
+    def __init__(self, start_rule: Optional[Rule] = None,
                  save_dir: Optional[str] = None, 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.
         """
         self.model_name: Optional[str] = model_name
-        self.save_dir = save_dir
-        self.start_rule = start_rule
+        self.save_dir: Optional[str] = save_dir
+        self.start_rule: Optional[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)
+        self.viewer: Optional[RDRCaseViewer] = RDRCaseViewer.instances[0]\
+            if RDRCaseViewer and any(RDRCaseViewer.instances) else None
+        self.input_node: Optional[Rule] = None
+        self.update_model()
+
+    def update_model(self):
+        """
+        Update the model from the model directory if it exists.
+        """
+        if self.save_dir is not None and self.model_name is not None:
+            model_path = os.path.join(self.save_dir, self.model_name)
+            if os.path.exists(model_path):
+                try:
+                    self.update_from_python(model_path, update_rule_tree=True)
+                except (FileNotFoundError, ModuleNotFoundError) as e:
+                    pass
+
+    def write_rdr_metadata_to_pyton_file(self, file: TextIOWrapper):
+        """
+        Write the metadata of the RDR classifier to a python file.
+
+        :param file: The file to write the metadata to.
+        """
+        file.write(f"name = \'{self.name}\'\n")
+        file.write(f"case_type = {self.case_type.__name__ if self.case_type is not None else None}\n")
+        file.write(f"case_name = \'{self.case_name}\'\n")
+
+    def update_rdr_metadata_from_python(self, module: ModuleType):
+        """
+        Update the RDR metadata from the module that contains the RDR classifier function.
+
+        :param module: The module that contains the RDR classifier function.
+        """
+        try:
+            self.name = module.name if hasattr(module, "name") else self.start_rule.conclusion_name
+            self.case_type = module.case_type
+            self.case_name = module.case_name if hasattr(module, "case_name") else f"{self.case_type.__name__}.{self.name}"
+        except AttributeError as e:
+            logger.warning(f"Could not update the RDR metadata from the module {module.__name__}. "
+                           f"Make sure the module has the required attributes: {e}")
+
+    def render_evaluated_rule_tree(self, filename: str, show_full_tree: bool = False) -> None:
+        if show_full_tree:
+            start_rule = self.start_rule if self.input_node is None else self.input_node
+            render_tree(start_rule, use_dot_exporter=True, filename=filename)
+        else:
+            evaluated_rules = self.get_evaluated_rule_tree()
+            if evaluated_rules is not None and len(evaluated_rules) > 0:
+                render_tree(evaluated_rules[0], use_dot_exporter=True, filename=filename,
+                            only_nodes=evaluated_rules)
+
+    def get_contributing_rules(self) -> Optional[List[Rule]]:
+        """
+        Get the contributing rules of the classifier.
+
+        :return: The contributing rules.
+        """
+        if self.start_rule is None:
+            return None
+        return [r for r in self.get_fired_rule_tree() if r.contributed]
+
+    def get_fired_rule_tree(self) -> Optional[List[Rule]]:
+        """
+        Get the fired rule tree of the classifier.
+
+        :return: The fired rule tree.
+        """
+        if self.start_rule is None:
+            return None
+        return [r for r in self.get_evaluated_rule_tree() if r.fired]
+
+    def get_evaluated_rule_tree(self) -> Optional[List[Rule]]:
+        """
+        Get the evaluated rule tree of the classifier.
+
+        :return: The evaluated rule tree.
+        """
+        if self.start_rule is None:
+            return None
+        start_rule = self.start_rule
+        evaluated_rule_tree = [r for r in [start_rule] + list(start_rule.descendants) if r.evaluated]
+        return evaluated_rule_tree
 
     def save(self, save_dir: Optional[str] = None, model_name: Optional[str] = None,
              package_name: Optional[str] = None) -> str:
@@ -137,18 +226,43 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :param package_name: The name of the package that contains the RDR classifier function, this
         is required in case of relative imports in the generated python file.
         """
+        rdr: Optional[RippleDownRules] = None
         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.save_dir = load_dir
-        rdr.model_name = model_name
+        if os.path.exists(json_file + ".json"):
+            rdr = cls.from_json_file(json_file)
         try:
-            rdr.update_from_python(model_dir, package_name=package_name)
+            if rdr is None:
+                rdr = cls.from_python(model_dir, parent_package_name=package_name)
+            else:
+                rdr.update_from_python(model_dir, parent_package_name=package_name)
             rdr.to_json_file(json_file)
-        except (FileNotFoundError, ValueError, SyntaxError) as e:
+        except (FileNotFoundError, ValueError, SyntaxError, ModuleNotFoundError) as e:
             logger.warning(f"Could not load the python file for the model {model_name} from {model_dir}. "
                            f"Make sure the file exists and is valid.")
+            if rdr is None:
+                raise RDRLoadError(f"Could not load the rdr model {model_name} from {model_dir}, error is {e}")
             rdr.save(save_dir=load_dir, model_name=model_name, package_name=package_name)
+        rdr.save_dir = load_dir
+        rdr.model_name = model_name
+        return rdr
+
+    @classmethod
+    def from_python(cls, model_path: str,
+                    python_file_path: Optional[str] = None,
+                    parent_package_name: Optional[str] = None) -> Self:
+        """
+        Load the RDR classifier from a generated python file.
+
+        :param model_path: The directory where the generated python file is located.
+        :param python_file_path: The path to the generated python file that contains the RDR classifier function.
+        :param parent_package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
+        :return: An instance of the RDR classifier.
+        """
+        rdr = cls()
+        rdr.update_from_python(model_path, parent_package_name=parent_package_name, python_file_path=python_file_path,
+                               update_rule_tree=True)
         return rdr
 
     @abstractmethod
@@ -162,16 +276,6 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         """
         pass
 
-    def set_viewer(self, viewer: RDRCaseViewer):
-        """
-        Set the viewer for the classifier.
-
-        :param viewer: The viewer to set.
-        """
-        self.viewer = viewer
-        if self.viewer is not None:
-            self.viewer.set_save_function(self.save)
-
     def fit(self, case_queries: List[CaseQuery],
             expert: Optional[Expert] = None,
             n_iter: int = None,
@@ -196,7 +300,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         num_rules: int = 0
         while not stop_iterating:
             for case_query in case_queries:
-                pred_cat = self.fit_case(case_query, expert=expert, **kwargs_for_fit_case)
+                pred_cat = self.fit_case(case_query, expert=expert, clear_expert_answers=False,
+                                         **kwargs_for_fit_case)
                 if case_query.target is None:
                     continue
                 target = {case_query.attribute_name: case_query.target(case_query.case)}
@@ -226,9 +331,37 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     def __call__(self, case: Union[Case, SQLTable]) -> Union[CallableExpression, Dict[str, CallableExpression]]:
         return self.classify(case)
 
+    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False, case_query: Optional[CaseQuery] = None) \
+            -> Optional[Union[CallableExpression, Dict[str, CallableExpression]]]:
+        """
+        Classify a case using the RDR classifier.
+
+        :param case: The case to classify.
+        :param modify_case: Whether to modify the original case attributes with the conclusion or not.
+        :param case_query: The case query containing the case to classify and the target category to compare the case with.
+        :return: The category that the case belongs to.
+        """
+        if self.start_rule is not None:
+            for rule in [self.start_rule] + list(self.start_rule.descendants):
+                rule.reset()
+        if self.start_rule is not None and self.start_rule.parent is None:
+            if self.input_node is None:
+                self.input_node = type(self.start_rule)(_parent=None, uid='0')
+                self.input_node.evaluated = False
+                self.input_node.fired = False
+            self.start_rule.parent = self.input_node
+            self.start_rule.weight = RDREdge.Empty
+        if self.input_node is not None:
+            data = case.__dict__ if is_dataclass(case) else case
+            if hasattr(case, "items"):
+                self.input_node.name = json.dumps({k: str(v) for k, v in data.items()}, indent=4)
+            else:
+                self.input_node.name = str(data)
+        return self._classify(case, modify_case=modify_case, case_query=case_query)
+
     @abstractmethod
-    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) \
+    def _classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) \
             -> Optional[Union[CallableExpression, Dict[str, CallableExpression]]]:
         """
         Classify a case.
@@ -244,6 +377,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                  expert: Optional[Expert] = None,
                  update_existing_rules: bool = True,
                  scenario: Optional[Callable] = None,
+                 ask_now: Callable = lambda _: True,
+                 clear_expert_answers: bool = True,
                  **kwargs) \
             -> Union[CallableExpression, Dict[str, CallableExpression]]:
         """
@@ -255,6 +390,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         :param update_existing_rules: Whether to update the existing same conclusion type rules that already gave
         some conclusions with the type required by the case query.
         :param scenario: The scenario at which the case was created, this is used to recreate the case if needed.
+        :param ask_now: Whether to ask the expert for refinements or alternatives.
+        :param clear_expert_answers: Whether to clear expert answers after saving the new rule.
         :return: The category that the case belongs to.
         """
         if case_query is None:
@@ -264,14 +401,15 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         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
         case_query.scenario = scenario if case_query.scenario is None else case_query.scenario
+        case_query.rdr = self
 
-        expert = expert or Human(viewer=self.viewer,
-                                 answers_save_path=self.save_dir + '/expert_answers'
+        expert = expert or Human(answers_save_path=self.save_dir + '/expert_answers'
                                  if self.save_dir else None)
         if case_query.target is None:
             case_query_cp = copy(case_query)
             conclusions = self.classify(case_query_cp.case, modify_case=True, case_query=case_query_cp)
-            if self.should_i_ask_the_expert_for_a_target(conclusions, case_query_cp, update_existing_rules):
+            if (self.should_i_ask_the_expert_for_a_target(conclusions, case_query_cp, update_existing_rules)
+                    and ask_now(case_query_cp.case)):
                 expert.ask_for_conclusion(case_query_cp)
                 case_query.target = case_query_cp.target
             if case_query.target is None:
@@ -283,7 +421,8 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
         if self.save_dir is not None:
             self.save()
-            expert.clear_answers()
+            if clear_expert_answers:
+                expert.clear_answers()
 
         return fit_case_result
 
@@ -356,6 +495,61 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     def type_(self):
         return self.__class__
 
+    @classmethod
+    def get_json_file_path(cls, model_path: str) -> str:
+        """
+        Get the path to the saved json file.
+
+        :param model_path : The path to the model directory.
+        :return: The path to the saved model.
+        """
+        model_name = cls.get_model_name_from_model_path(model_path)
+        return os.path.join(model_path, cls.metadata_folder, f"{model_name}.json")
+
+    @classmethod
+    def get_generated_cases_file_path(cls, model_path: str) -> str:
+        """
+        Get the path to the python file that contains the RDR classifier cases.
+
+        :param model_path : The path to the model directory.
+        :return: The path to the generated python file.
+        """
+        return cls.get_generated_python_file_path(model_path).replace(".py", "_cases.py")
+
+    @classmethod
+    def get_generated_defs_file_path(cls, model_path: str) -> str:
+        """
+        Get the path to the python file that contains the RDR classifier function definitions.
+
+        :param model_path : The path to the model directory.
+        :return: The path to the generated python file.
+        """
+        return cls.get_generated_python_file_path(model_path).replace(".py", "_defs.py")
+
+    @classmethod
+    def get_generated_python_file_path(cls, model_path: str) -> str:
+        """
+        Get the path to the python file that contains the RDR classifier function.
+
+        :param model_path : The path to the model directory.
+        :return: The path to the generated python file.
+        """
+        model_name = cls.get_model_name_from_model_path(model_path)
+        return os.path.join(model_path, f"{model_name}.py")
+
+    @classmethod
+    def get_model_name_from_model_path(cls, model_path: str) -> str:
+        """
+        Get the model name from the model path.
+
+        :param model_path: The path to the model directory.
+        :return: The name of the model.
+        """
+        file_name = get_file_that_ends_with(model_path, f"_{cls.get_acronym().lower()}.py")
+        if file_name is None:
+            raise FileNotFoundError(f"Could not find the python file for the model in the given path: {model_path}.")
+        return file_name.replace('.py', '')
+
     @property
     def generated_python_file_name(self) -> str:
         if self._generated_python_file_name is None:
@@ -379,13 +573,17 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         pass
 
     @abstractmethod
-    def update_from_python(self, model_dir: str, package_name: Optional[str] = None):
+    def update_from_python(self, model_dir: str, parent_package_name: Optional[str] = None,
+                           python_file_path: Optional[str] = None,
+                           update_rule_tree: bool = False):
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
         :param model_dir: The directory where the generated python file is located.
-        :param package_name: The name of the package that contains the RDR classifier function, this
+        :param parent_package_name: The name of the package that contains the RDR classifier function, this
         is required in case of relative imports in the generated python file.
+        :param python_file_path: The path to the generated python file that contains the RDR classifier function.
+        :param update_rule_tree: Whether to update the rule tree from the python file or not.
         """
         pass
 
@@ -414,41 +612,363 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         return module.classify
 
 
+class TreeBuilder(ast.NodeVisitor, ABC):
+    """Parses an AST of nested if-elif statements and reconstructs the tree."""
+
+    def __init__(self):
+        self.root: Optional[Rule] = None
+        self.current_parent: Optional[Rule] = None
+        self.current_edge: Optional[RDREdge] = None
+        self.default_conclusion: Optional[str] = None
+
+    def visit_FunctionDef(self, node):
+        """Finds the main function and starts parsing its body."""
+        for stmt in node.body:
+            self.visit(stmt)
+
+    def visit_If(self, node):
+        """Handles if-elif blocks and creates nodes."""
+        condition = self.get_condition_name(node.test)
+        if condition is None:
+            return
+        rule_uid = condition.split("conditions_")[1]
+
+        new_rule_type = self.get_new_rule_type(node)
+        new_node = new_rule_type(conditions=condition, _parent=self.current_parent, uid=rule_uid)
+        if self.current_parent is not None:
+            self.update_current_parent(new_node)
+
+        if self.current_parent is None and self.root is None:
+            self.root = new_node
+
+        self.current_parent = new_node
+
+        # Parse the body of the if statement
+        for stmt in node.body:
+            self.current_edge = self.get_refinement_edge(node)
+            self.current_parent = new_node
+            self.visit(stmt)
+
+        # Parse elif/else
+        for stmt in node.orelse:
+            self.current_edge = self.get_alternative_edge(node)
+            self.current_parent = new_node
+            if isinstance(stmt, ast.If): # elif case
+                self.visit_If(stmt)
+            else:  # else case (return)
+                self.process_else_statement(stmt)
+        self.current_parent = new_node
+        self.current_edge = None
+
+    @abstractmethod
+    def process_else_statement(self, stmt: ast.AST):
+        """
+        Process the else statement in the if-elif-else block.
+
+        :param stmt: The else statement to process.
+        """
+        pass
+
+    @abstractmethod
+    def get_refinement_edge(self, node: ast.AST) -> RDREdge:
+        """
+        :param node: The current AST node to determine the edge type from.
+        :return: The refinement edge type.
+        """
+        pass
+
+    @abstractmethod
+    def get_alternative_edge(self, node: ast.AST) -> RDREdge:
+        """
+        :param node: The current AST node to determine the alternative edge type from.
+        :return: The alternative edge type.
+        """
+        pass
+
+    @abstractmethod
+    def get_new_rule_type(self, node: ast.AST) -> Type[Rule]:
+        """
+        Get the new rule type to create.
+        :param node: The current AST node to determine the rule type from.
+        :return: The new rule type.
+        """
+        pass
+
+    @abstractmethod
+    def update_current_parent(self, new_node: Rule):
+        """
+        Update the current parent rule with the new node.
+        :param new_node: The new node to set as the current parent.
+        """
+        pass
+
+    def visit_Return(self, node):
+        """Handles return statements as leaf nodes."""
+        if isinstance(node.value, ast.Call):
+            return_value = node.value.func.id
+        else:
+            return_value = ast.literal_eval(node.value)
+        if self.current_parent is None:
+            self.default_conclusion = return_value
+        else:
+            self.current_parent.conclusion = return_value
+
+    def get_condition_name(self, node):
+        """Extracts the condition function name from an AST expression."""
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+            return node.func.id
+        return None
+
+class SingleClassTreeBuilder(TreeBuilder):
+    """Parses an AST of generated SingleClassRDR classifier and reconstructs the rdr tree."""
+
+    def get_new_rule_type(self, node: ast.AST) -> Type[Rule]:
+        return SingleClassRule
+
+    def get_refinement_edge(self, node: ast.AST) -> RDREdge:
+        return RDREdge.Refinement
+
+    def get_alternative_edge(self, node: ast.AST) -> RDREdge:
+        return RDREdge.Alternative
+
+    def update_current_parent(self, new_node: Rule):
+        if self.current_edge == RDREdge.Alternative:
+            self.current_parent.alternative = new_node
+        elif self.current_edge == RDREdge.Refinement:
+            self.current_parent.refinement = new_node
+
+    def process_else_statement(self, stmt: ast.AST):
+        """Handles the else statement in the if-elif-else block."""
+        if isinstance(stmt, ast.Return):
+            self.current_parent = None
+            self.visit_Return(stmt)
+        else:
+            raise ValueError(f"Unexpected statement in else block: {stmt}")
+
+
+class MultiClassTreeBuilder(TreeBuilder):
+    """Parses an AST of generated MultiClassRDR classifier and reconstructs the rdr tree."""
+
+    def visit_If(self, stmt: ast.If):
+        super().visit_If(stmt)
+        if isinstance(self.current_parent, (MultiClassTopRule, MultiClassFilterRule)):
+            self.current_parent.conclusion = self.current_parent.conditions.replace("conditions_", "conclusion_")
+
+    def visit_Return(self, node):
+        pass
+
+    def get_new_rule_type(self, node: ast.AST) -> Type[Rule]:
+        if self.current_edge == RDREdge.Refinement:
+            return MultiClassStopRule
+        elif self.current_edge == RDREdge.Filter:
+            return MultiClassFilterRule
+        elif self.current_edge in [RDREdge.Next, None]:
+            return MultiClassTopRule
+        elif self.current_edge == RDREdge.Alternative:
+            return self.get_refinement_rule_type(node)
+        else:
+            raise ValueError(f"Unknown edge type: {self.current_edge}")
+
+    def get_alternative_edge(self, node: ast.AST) -> RDREdge:
+        if isinstance(self.current_parent, MultiClassTopRule):
+            return RDREdge.Next
+        else:
+            return RDREdge.Alternative
+
+    def get_refinement_edge(self, node: ast.AST) -> RDREdge:
+        rule_type = self.get_refinement_rule_type(node)
+        return self.get_refinement_edge_from_refinement_rule(rule_type)
+
+    def get_refinement_edge_from_refinement_rule(self, rule_type: Type[Rule]) -> RDREdge:
+        """
+        :param rule_type: The type of the rule to determine the refinement edge from.
+        :return: The refinement edge type based on the rule type.
+        """
+        if isinstance(self.current_parent, MultiClassRefinementRule):
+            return RDREdge.Alternative
+        if rule_type == MultiClassStopRule:
+            return RDREdge.Refinement
+        else:
+            return RDREdge.Filter
+
+    def get_refinement_rule_type(self, node: ast.AST) -> Type[Rule]:
+        """
+        :param node: The current AST node to determine the rule type from.
+        :return: The rule type based on the node body.
+        """
+        for stmt in node.body:
+            if len(node.body) == 1 and isinstance(stmt, ast.Pass):
+                return MultiClassStopRule
+            elif isinstance(stmt, ast.If):
+                return self.get_refinement_rule_type(stmt)
+            else:
+                return MultiClassFilterRule
+        raise ValueError(f"Could not determine the refinement rule type from the node: {node} as it has an empty body.")
+
+    def update_current_parent(self, new_node: Rule):
+        if isinstance(new_node, MultiClassRefinementRule):
+            if isinstance(self.current_parent, MultiClassTopRule):
+                new_node.top_rule = self.current_parent
+            elif hasattr(self.current_parent, "top_rule"):
+                new_node.top_rule = self.current_parent.top_rule
+            else:
+                raise ValueError(f"Could not set the top rule for the refinement rule: {new_node}")
+        if self.current_edge in [RDREdge.Alternative, RDREdge.Next, None]:
+            self.current_parent.alternative = new_node
+        elif self.current_edge in [RDREdge.Refinement, RDREdge.Filter]:
+            self.current_parent.refinement = new_node
+
+    def process_else_statement(self, stmt: ast.AST):
+        """Handles the else statement in the if-elif-else block."""
+        pass
+
 class RDRWithCodeWriter(RippleDownRules, ABC):
 
-    def update_from_python(self, model_dir: str, package_name: Optional[str] = None):
+    @classmethod
+    def read_rule_tree_from_python(cls, model_path: str, python_file_path: Optional[str] = None) -> Rule:
+        """
+        :param model_path: The path to the generated python file that contains the RDR classifier function.
+        :param python_file_path: The path to the generated python file that contains the RDR classifier function.
+        """
+        if python_file_path is None:
+            python_file_path = cls.get_generated_python_file_path(model_path)
+        with open(python_file_path, "r") as f:
+            source_code = f.read()
+
+        tree = ast.parse(source_code)
+        builder = cls.get_tree_builder_class()()
+
+        # Find and process the function
+        for node in tree.body:
+            if isinstance(node, ast.FunctionDef) and node.name == "classify":
+                builder.visit_FunctionDef(node)
+
+        return builder.root
+
+    @classmethod
+    @abstractmethod
+    def get_tree_builder_class(cls) -> Type[TreeBuilder]:
+        """
+        :return: The class that builds the rule tree from the generated python file.
+        This should be either SingleClassTreeBuilder or MultiClassTreeBuilder.
+        """
+        pass
+
+    @property
+    def all_rules(self) -> List[Rule]:
+        """
+        Get all rules in the classifier.
+
+        :return: A list of all rules in the classifier.
+        """
+        if self.start_rule is None:
+            return []
+        return [r for r in [self.start_rule] + list(self.start_rule.descendants) if r.conditions is not None]
+
+    def update_from_python(self, model_dir: str, parent_package_name: Optional[str] = None,
+                           python_file_path: Optional[str] = None, update_rule_tree: bool = False):
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
         :param model_dir: The directory where the generated python file is located.
-        :param package_name: The name of the package that contains the RDR classifier function, this
+        :param parent_package_name: The name of the package that contains the RDR classifier function, this
         is required in case of relative imports in the generated python file.
-        """
-        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)]
+        :param python_file_path: The path to the generated python file that contains the RDR classifier function.
+        :param update_rule_tree: Whether to update the rule tree from the python file or not.
+        """
+        if update_rule_tree:
+            self.start_rule = self.read_rule_tree_from_python(model_dir, python_file_path=python_file_path)
+        all_rules = self.all_rules
+        condition_func_names = [rule.generated_conditions_function_name for rule in all_rules]
+        conclusion_func_names = [rule.generated_conclusion_function_name for rule in all_rules
+                                 if not isinstance(rule, MultiClassStopRule)]
         all_func_names = condition_func_names + conclusion_func_names
-        filepath = f"{model_dir}/{self.generated_python_defs_file_name}.py"
-        cases_path = f"{model_dir}/{self.generated_python_cases_file_name}.py"
-        cases_import_path = get_import_path_from_path(model_dir)
-        cases_import_path = f"{cases_import_path}.{self.generated_python_cases_file_name}" if cases_import_path \
-            else self.generated_python_cases_file_name
-        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, package_name=package_name)
-        for rule in [self.start_rule] + list(self.start_rule.descendants):
+
+        main_module, defs_module, cases_module = self.get_and_import_model_python_modules(
+                                                        model_dir,
+                                                        python_file_path=python_file_path,
+                                                        parent_package_name=parent_package_name)
+        self.generated_python_file_name = Path(main_module.__file__).name.replace(".py", "")
+
+        self.update_rdr_metadata_from_python(main_module)
+
+        functions_source = extract_function_source(defs_module.__file__,
+                                                   all_func_names, include_signature=True)
+        scope = extract_imports(defs_module.__file__, package_name=parent_package_name)
+
+        cases_source, cases_scope = None, None
+        if cases_module:
+            with open(cases_module.__file__, "r") as f:
+                cases_source = f.read()
+            cases_scope = extract_imports(cases_module.__file__, package_name=parent_package_name)
+
+        with open(main_module.__file__, "r") as f:
+            main_source = f.read()
+        main_scope = extract_imports(main_module.__file__, package_name=parent_package_name)
+        attribute_name_line = [l for l in main_source.split('\n') if "attribute_name = " in l]
+        conclusion_name = None
+        if len(attribute_name_line) > 0:
+            conclusion_name = eval(attribute_name_line[0].split('=')[-1].strip(), main_scope)
+
+        for rule in all_rules:
             if rule.conditions is not None:
-                rule.conditions.user_input = functions_source[f"conditions_{rule.uid}"]
-                rule.conditions.scope = scope
-                if os.path.exists(cases_path):
-                    module = importlib.import_module(cases_import_path, package=package_name)
-                    importlib.reload(module)
-                    rule.corner_case_metadata = module.__dict__.get(f"corner_case_{rule.uid}", 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
+                conditions_wrapper_func_name = rule.generated_conditions_function_name
+                user_input = functions_source[conditions_wrapper_func_name]
+                user_input = '\n'.join(user_input.split("\n")[1:])  # Remove the function signature line
+                rule.conditions = CallableExpression(user_input, (bool,), scope=scope)
+                if cases_module:
+                    try:
+                        rule.corner_case_metadata = cases_module.__dict__[rule.generated_corner_case_object_name]
+                    except KeyError:
+                        case_def_lines = [l for l in cases_source.split('\n') if rule.generated_corner_case_object_name in l]
+                        if len(case_def_lines) > 0:
+                            case_def_line = case_def_lines[0].split('=')[-1].strip()
+                            rule.corner_case_metadata = eval(case_def_line, cases_scope)
+
+            if not isinstance(rule, MultiClassStopRule):
+                if conclusion_name:
+                    rule.conclusion_name = conclusion_name
+                user_input = functions_source[rule.generated_conclusion_function_name]
+                split_user_input = user_input.split("\n")
+                user_input = '\n'.join(split_user_input[1:])
+                conclusion_func = defs_module.__dict__.get(rule.generated_conclusion_function_name)
+                if conclusion_func is None:
+                    function_signature = split_user_input[0]
+                    return_type_hint_str = function_signature.split('->')[-1].strip(' :')
+                    return_type_hint = eval(return_type_hint_str, scope)
+                    conclusion_type = get_type_from_type_hint(return_type_hint)
+                else:
+                    conclusion_type = get_function_return_type(conclusion_func)
+                rule.conclusion = CallableExpression(user_input, conclusion_type, scope=scope,
+                                                     mutually_exclusive=self.mutually_exclusive)
+
+    @classmethod
+    def get_and_import_model_python_modules(cls, model_dir: str,
+                                            python_file_path: Optional[str] = None,
+                                            parent_package_name: Optional[str] = None)\
+            -> Tuple[ModuleType, ModuleType, ModuleType]:
+        """
+        Get and import the python modules that contain the RDR classifier function, definitions, and corner cases.
+
+        :param model_dir: The path to the directory where the generated python files are located.
+        :param python_file_path: The path to the generated python file that contains the RDR classifier function.
+        :param parent_package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
+        :return: A tuple containing the main module, defs module, and cases module.
+        """
+        if python_file_path is None:
+            main_file_path = cls.get_generated_python_file_path(model_dir)
+        else:
+            main_file_path = python_file_path
+        if not os.path.exists(main_file_path):
+            raise ModuleNotFoundError(main_file_path)
+
+        defs_file_path = main_file_path.replace(".py", "_defs.py")
+        cases_path = main_file_path.replace(".py", "_cases.py")
+
+        main_module, defs_module, cases_module = get_and_import_python_modules_in_a_package(
+            [main_file_path, defs_file_path, cases_path], parent_package_name=parent_package_name)
+        return main_module, defs_module, cases_module
 
     @abstractmethod
     def write_rules_as_source_code_to_file(self, rule: Rule, file, parent_indent: str = "",
@@ -492,6 +1012,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         defs_imports = get_imports_from_types(defs_types, defs_file_name, package_name)
         corner_cases_imports = get_imports_from_types(corner_cases_types, cases_file_name, package_name)
 
+        defs_imports.append(f"from ripple_down_rules import *")
         # Add the imports to the defs file
         with open(defs_file_name, "w") as f:
             f.write('\n'.join(defs_imports) + "\n\n\n")
@@ -511,6 +1032,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             f.write(f"attribute_name = '{self.attribute_name}'\n")
             f.write(f"conclusion_type = ({', '.join([ct.__name__ for ct in self.conclusion_type])},)\n")
             f.write(f"mutually_exclusive = {self.mutually_exclusive}\n")
+            self.write_rdr_metadata_to_pyton_file(f)
             f.write(f"\n\n{func_def}")
             f.write(f"{' ' * 4}if not isinstance(case, Case):\n"
                     f"{' ' * 4}    case = create_case(case, max_recursion_idx=3)\n""")
@@ -527,7 +1049,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         pass
 
-    def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
+    def _get_types_to_import(self) -> Tuple[Set[Union[Type, Callable]], Set[Type], Set[Type]]:
         """
         :return: The types of the main, defs, and corner cases files of the RDR classifier that will be imported.
         """
@@ -550,7 +1072,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         main_types.update({Union, Optional})
         defs_types.add(Union)
         main_types.update({Case, create_case})
-        main_types = main_types.difference(defs_types)
+        # main_types = main_types.difference(defs_types)
         return main_types, defs_types, cases_types
 
     @property
@@ -576,9 +1098,8 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         :return: The type of the conclusion of the RDR classifier.
         """
         all_types = []
-        if self.start_rule is not None:
-            for rule in [self.start_rule] + list(self.start_rule.descendants):
-                all_types.extend(list(rule.conclusion.conclusion_type))
+        for rule in self.all_rules:
+            all_types.extend(list(rule.conclusion.conclusion_type))
         return tuple(set(all_types))
 
     @property
@@ -635,6 +1156,10 @@ class SingleClassRDR(RDRWithCodeWriter):
         super(SingleClassRDR, self).__init__(**kwargs)
         self.default_conclusion: Optional[Any] = default_conclusion
 
+    @classmethod
+    def get_tree_builder_class(cls) -> Type[TreeBuilder]:
+        return SingleClassTreeBuilder
+
     def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Union[CaseAttribute, CallableExpression, None]:
         """
@@ -649,7 +1174,7 @@ class SingleClassRDR(RDRWithCodeWriter):
             self.default_conclusion = case_query.default_value
 
         pred = self.evaluate(case_query.case)
-        if pred.conclusion(case_query.case) != case_query.target_value:
+        if (not pred.fired and self.default_conclusion is None) or pred.conclusion(case_query.case) != case_query.target_value:
             expert.ask_for_conditions(case_query, pred)
             pred.fit_rule(case_query)
 
@@ -666,8 +1191,8 @@ class SingleClassRDR(RDRWithCodeWriter):
             expert.ask_for_conditions(case_query)
             self.start_rule = SingleClassRule.from_case_query(case_query)
 
-    def classify(self, case: Case, modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) -> Optional[Any]:
+    def _classify(self, case: Case, modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) -> Optional[Any]:
         """
         Classify a case by recursively evaluating the rules until a rule fires or the last rule is reached.
 
@@ -677,6 +1202,11 @@ class SingleClassRDR(RDRWithCodeWriter):
         """
         pred = self.evaluate(case)
         conclusion = pred.conclusion(case) if pred is not None and pred.fired else self.default_conclusion
+        if pred is not None and pred.fired:
+            pred.contributed = True
+            pred.last_conclusion = conclusion
+            if case_query is not None:
+                pred.contributed_to_case_query = True
         if pred is not None and pred.fired and case_query is not None:
             if pred.corner_case_metadata is None and conclusion is not None \
                     and type(conclusion) in case_query.core_attribute_type:
@@ -781,8 +1311,12 @@ class MultiClassRDR(RDRWithCodeWriter):
         super(MultiClassRDR, self).__init__(start_rule, **kwargs)
         self.mode: MCRDRMode = mode
 
-    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) -> Set[Any]:
+    @classmethod
+    def get_tree_builder_class(cls) -> Type[TreeBuilder]:
+        return MultiClassTreeBuilder
+
+    def _classify(self, case: Union[Case, SQLTable], modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) -> Set[Any]:
         evaluated_rule = self.start_rule
         self.conclusions = []
         while evaluated_rule:
@@ -794,6 +1328,13 @@ class MultiClassRDR(RDRWithCodeWriter):
                             and any(
                         ct in case_query.core_attribute_type for ct in map(type, make_list(rule_conclusion))):
                         evaluated_rule.corner_case_metadata = CaseFactoryMetaData.from_case_query(case_query)
+                if rule_conclusion is not None and any(make_list(rule_conclusion)):
+                    evaluated_rule.contributed = True
+                    evaluated_rule.last_conclusion = rule_conclusion
+                    if case_query is not None:
+                        rule_conclusion_types = set(map(type, make_list(rule_conclusion)))
+                        if are_results_subclass_of_types(rule_conclusion_types, case_query.core_attribute_type):
+                            evaluated_rule.contributed_to_case_query = True
                 self.add_conclusion(rule_conclusion)
             evaluated_rule = next_rule
         return make_set(self.conclusions)
@@ -860,6 +1401,9 @@ class MultiClassRDR(RDRWithCodeWriter):
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, filename, parent_indent, defs_file=defs_file,
                                                         cases_file=cases_file, package_name=package_name)
+            elif isinstance(rule, MultiClassTopRule):
+                with open(filename, "a") as file:
+                    file.write(f"{parent_indent}return conclusions\n")
 
     @property
     def conclusion_type_hint(self) -> str:
@@ -869,8 +1413,9 @@ class MultiClassRDR(RDRWithCodeWriter):
         else:
             return f"Set[Union[{', '.join(conclusion_types)}]]"
 
-    def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
+    def _get_types_to_import(self) -> Tuple[Set[Union[Type, Callable]], Set[Type], Set[Type]]:
         main_types, defs_types, cases_types = super()._get_types_to_import()
+        main_types.add(get_an_updated_case_copy)
         main_types.update({Set, make_set})
         defs_types.update({List, Set})
         return main_types, defs_types, cases_types
@@ -884,7 +1429,7 @@ class MultiClassRDR(RDRWithCodeWriter):
         """
         if not self.start_rule:
             conditions = expert.ask_for_conditions(case_query)
-            self.start_rule = MultiClassTopRule.from_case_query(case_query)
+            self.start_rule: MultiClassTopRule = MultiClassTopRule.from_case_query(case_query)
 
     @property
     def last_top_rule(self) -> Optional[MultiClassTopRule]:
@@ -902,28 +1447,43 @@ class MultiClassRDR(RDRWithCodeWriter):
         Stop a wrong conclusion by adding a stopping rule.
         """
         rule_conclusion = evaluated_rule.conclusion(case_query.case)
-        if is_conflicting(rule_conclusion, case_query.target_value):
-            self.stop_conclusion(case_query, expert, evaluated_rule)
-        else:
+        stop: bool = False
+        add_filter_rule: bool = False
+        if is_value_conflicting(rule_conclusion, case_query.target_value):
+            if make_set(case_query.target_value).issubset(rule_conclusion):
+                add_filter_rule = True
+            else:
+                stop = True
+        elif make_set(case_query.core_attribute_type).issubset(make_set(evaluated_rule.conclusion.conclusion_type)):
+            if make_set(case_query.target_value).issubset(rule_conclusion):
+                add_filter_rule = True
+
+        if not stop:
             self.add_conclusion(rule_conclusion)
+        if stop or add_filter_rule:
+            refinement_type = MultiClassStopRule if stop else MultiClassFilterRule
+            self.stop_or_filter_conclusion(case_query, expert, evaluated_rule, refinement_type=refinement_type)
 
-    def stop_conclusion(self, case_query: CaseQuery,
-                        expert: Expert, evaluated_rule: MultiClassTopRule):
+    def stop_or_filter_conclusion(self, case_query: CaseQuery,
+                                  expert: Expert, evaluated_rule: MultiClassTopRule,
+                                  refinement_type: Type[MultiClassRefinementRule] = MultiClassStopRule):
         """
         Stop a conclusion by adding a stopping rule.
 
         :param case_query: The case query to stop the conclusion for.
         :param expert: The expert to ask for differentiating features as new rule conditions.
         :param evaluated_rule: The evaluated rule to ask the expert about.
+        :param refinement_type: The refinement type to use.
         """
         conditions = expert.ask_for_conditions(case_query, evaluated_rule)
-        evaluated_rule.fit_rule(case_query)
-        if self.mode == MCRDRMode.StopPlusRule:
-            self.stop_rule_conditions = conditions
-        if self.mode == MCRDRMode.StopPlusRuleCombined:
-            new_top_rule_conditions = conditions.combine_with(evaluated_rule.conditions)
-            case_query.conditions = new_top_rule_conditions
-            self.add_top_rule(case_query)
+        evaluated_rule.fit_rule(case_query, refinement_type=refinement_type)
+        if refinement_type is MultiClassStopRule:
+            if self.mode == MCRDRMode.StopPlusRule:
+                self.stop_rule_conditions = conditions
+            if self.mode == MCRDRMode.StopPlusRuleCombined:
+                new_top_rule_conditions = conditions.combine_with(evaluated_rule.conditions)
+                case_query.conditions = new_top_rule_conditions
+                self.add_top_rule(case_query)
 
     def add_rule_for_case(self, case_query: CaseQuery, expert: Expert):
         """
@@ -1004,6 +1564,39 @@ class GeneralRDR(RippleDownRules):
         super(GeneralRDR, self).__init__(**kwargs)
         self.all_figs: List[Figure] = [sr.fig for sr in self.start_rules_dict.values()]
 
+    @classmethod
+    def from_python(cls, model_dir: str, python_file_path: Optional[str] = None,
+                    parent_package_name: Optional[str] = None) -> Self:
+        """
+        Create an instance of the class from a python file.
+
+        :param model_dir: The path to the directory containing the python file.
+        :param python_file_path: The path to the python file, if not provided, it will be generated from the model_dir.
+        :param parent_package_name: The name of the package that contains the RDR classifier function, this
+        is required in case of relative imports in the generated python file.
+        :return: An instance of the class.
+        """
+        grdr = cls()
+        grdr.update_from_python(model_dir, parent_package_name=parent_package_name, python_file_path=python_file_path,
+                                update_rule_tree=True)
+        return grdr
+
+    @classmethod
+    def get_rdr_type_from_acronym(cls, acronym: str) -> Type[Union[SingleClassRDR, MultiClassRDR]]:
+        """
+        Get the type of the ripple down rules classifier from the acronym.
+
+        :param acronym: The acronym of the ripple down rules classifier.
+        :return: The type of the ripple down rules classifier.
+        """
+        acronym = acronym.lower()
+        if acronym == "scrdr":
+            return SingleClassRDR
+        elif acronym == "mcrdr":
+            return MultiClassRDR
+        else:
+            raise ValueError(f"Unknown RDR type acronym: {acronym}")
+
     def add_rdr(self, rdr: Union[SingleClassRDR, MultiClassRDR], case_query: Optional[CaseQuery] = None):
         """
         Add a ripple down rules classifier to the map of classifiers.
@@ -1027,8 +1620,8 @@ class GeneralRDR(RippleDownRules):
     def start_rules(self) -> List[Union[SingleClassRule, MultiClassTopRule]]:
         return [rdr.start_rule for rdr in self.start_rules_dict.values()]
 
-    def classify(self, case: Any, modify_case: bool = False,
-                 case_query: Optional[CaseQuery] = None) -> Optional[Dict[str, Any]]:
+    def _classify(self, case: Any, modify_case: bool = False,
+                  case_query: Optional[CaseQuery] = None) -> Optional[Dict[str, Any]]:
         """
         Classify a case by going through all RDRs and adding the categories that are classified, and then restarting
         the classification until no more categories can be added.
@@ -1109,23 +1702,45 @@ class GeneralRDR(RippleDownRules):
             new_rdr.case_name = data["case_name"]
         return new_rdr
 
-    def update_from_python(self, model_dir: str, package_name: Optional[str] = None) -> None:
+    def update_from_python(self, model_dir: str, parent_package_name: Optional[str] = None,
+                           python_file_path: Optional[str] = None,
+                           update_rule_tree: bool = False) -> None:
         """
         Update the rules from the generated python file, that might have been modified by the user.
 
         :param model_dir: The directory where the model is stored.
-        :param package_name: The name of the package that contains the RDR classifier function, this
+        :param parent_package_name: The name of the package that contains the RDR classifier function, this
         is required in case of relative imports in the generated python file.
-        """
-        for rdr in self.start_rules_dict.values():
-            rdr.update_from_python(model_dir, package_name=package_name)
+        :param python_file_path: The path to the python file, if not provided, it will be generated from the model_dir.
+        :param update_rule_tree: Whether to update the rule tree from the python file or not.
+        """
+        if update_rule_tree:
+            if python_file_path is None:
+                main_python_file_path = self.get_generated_python_file_path(model_dir)
+            else:
+                main_python_file_path = python_file_path
+            main_module = get_and_import_python_module(main_python_file_path, parent_package_name=parent_package_name)
+            classifiers_dict = main_module.classifiers_dict
+            self.start_rules_dict = {}
+            for rdr_name, rdr_module in classifiers_dict.items():
+                rdr_acronym = rdr_module.__name__.split('_')[-1]
+                rdr_type = self.get_rdr_type_from_acronym(rdr_acronym)
+                rdr_model_path = main_python_file_path.replace('_rdr.py', f'_{rdr_name}_{rdr_acronym}.py')
+                rdr = rdr_type.from_python(model_dir, python_file_path=rdr_model_path,
+                                           parent_package_name=parent_package_name)
+                self.start_rules_dict[rdr_name] = rdr
+
+            self.update_rdr_metadata_from_python(main_module)
+        else:
+            for rdr in self.start_rules_dict.values():
+                rdr.update_from_python(model_dir, parent_package_name=parent_package_name)
 
     def _write_to_python(self, model_dir: str, package_name: Optional[str] = None) -> None:
         """
         Write the tree of rules as source code to a file.
 
         :param model_dir: The directory where the model is stored.
-        :param relative_imports: Whether to use relative imports in the generated python file.
+        :param package_name: The name of the package that contains the RDR classifier function.
         """
         for rdr in self.start_rules_dict.values():
             rdr._write_to_python(model_dir, package_name=package_name)
@@ -1133,6 +1748,7 @@ class GeneralRDR(RippleDownRules):
         file_path = model_dir + f"/{self.generated_python_file_name}.py"
         with open(file_path, "w") as f:
             f.write(self._get_imports(file_path=file_path, package_name=package_name) + "\n\n")
+            self.write_rdr_metadata_to_pyton_file(f)
             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")