ripple-down-rules 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

ripple_down_rules/datasets.py

@@ -18,6 +18,8 @@ from .rdr_decorators import RDRDecorator
 def load_cached_dataset(cache_file):
     """Loads the dataset from cache if it exists."""
     dataset = {}
+    if '.pkl' not in cache_file:
+        cache_file += ".pkl"
     for key in ["features", "targets", "ids"]:
         part_file = cache_file.replace(".pkl", f"_{key}.pkl")
         if not os.path.exists(part_file):
@@ -43,6 +45,9 @@ def save_dataset_to_cache(dataset, cache_file):
 
 def get_dataset(dataset_id, cache_file: Optional[str] = None):
     """Fetches dataset from cache or downloads it if not available."""
+    if cache_file is not None:
+        if not cache_file.endswith(".pkl"):
+            cache_file += ".pkl"
     dataset = load_cached_dataset(cache_file) if cache_file else None
     if dataset is None:
         print("Downloading dataset...")

ripple_down_rules/datastructures/enums.py

@@ -7,6 +7,20 @@ from typing_extensions import List, Dict, Any, Type
 from ripple_down_rules.utils import SubclassJSONSerializer
 
 
+class InteractionMode(Enum):
+    """
+    The interaction mode of the RDR.
+    """
+    IPythonOnly = auto()
+    """
+    IPythonOnly mode, the mode where the user uses only an Ipython shell to interact with the RDR.
+    """
+    GUI = auto()
+    """
+    GUI mode, the mode where the user uses a GUI to interact with the RDR.
+    """
+
+
 class Editor(str, Enum):
     """
     The editor that is used to edit the rules.

ripple_down_rules/experts.py

@@ -3,15 +3,14 @@ from __future__ import annotations
 import json
 from abc import ABC, abstractmethod
 
-from typing_extensions import Optional, Dict, TYPE_CHECKING, List, Type, Any
+from typing_extensions import Optional, TYPE_CHECKING, List
 
-from .datastructures.case import Case, CaseAttribute
 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 .prompt import prompt_user_for_expression, IPythonShell
-from .utils import get_all_subclasses, make_list
+from .user_interface.gui import RDRCaseViewer
+from .user_interface.prompt import UserPrompt
 
 if TYPE_CHECKING:
     from .rdr import Rule
@@ -66,12 +65,20 @@ class Human(Expert):
     The Human Expert class, an expert that asks the human to provide differentiating features and conclusions.
     """
 
+    def __init__(self, use_loaded_answers: bool = False, append: bool = False, viewer: Optional[RDRCaseViewer] = None):
+        """
+        Initialize the Human expert.
+
+        :param viewer: The RDRCaseViewer instance to use for prompting the user.
+        """
+        super().__init__(use_loaded_answers=use_loaded_answers, append=append)
+        self.user_prompt = UserPrompt(viewer)
+
     def save_answers(self, path: str):
         """
         Save the expert answers to a file.
 
         :param path: The path to save the answers to.
-        :param append: A flag to indicate if the answers should be appended to the file or not.
         """
         if self.append:
             # read the file and append the new answers
@@ -118,7 +125,7 @@ class Human(Expert):
         if user_input:
             condition = CallableExpression(user_input, bool, scope=case_query.scope)
         else:
-            user_input, condition = prompt_user_for_expression(case_query, PromptFor.Conditions)
+            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)
         case_query.conditions = condition
@@ -142,7 +149,7 @@ class Human(Expert):
                                                  mutually_exclusive=case_query.mutually_exclusive)
         else:
             show_current_and_corner_cases(case_query.case)
-            expert_input, expression = prompt_user_for_expression(case_query, PromptFor.Conclusion)
+            expert_input, expression = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conclusion)
             self.all_expert_answers.append(expert_input)
         case_query.target = expression
         return expression

ripple_down_rules/rdr.py

@@ -883,10 +883,12 @@ class GeneralRDR(RippleDownRules):
             f.write(f"{' ' * 4}return GeneralRDR._classify(classifiers_dict, case)\n")
 
     @property
-    def case_type(self) -> Type:
+    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:
@@ -900,10 +902,12 @@ class GeneralRDR(RippleDownRules):
         return importlib.import_module(f"{file_path.strip('./')}.{self.generated_python_file_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 self.start_rule is None or self.start_rule.corner_case is None:
+            return None
         if isinstance(self.start_rule.corner_case, Case):
             name = self.start_rule.corner_case._name
         else: