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

ripple_down_rules/experts.py

@@ -103,7 +103,7 @@ class Human(Expert):
     def ask_for_conditions(self, case_query: CaseQuery,
                            last_evaluated_rule: Optional[Rule] = None) \
             -> CallableExpression:
-        if not self.use_loaded_answers:
+        if not self.use_loaded_answers and self.user_prompt.viewer is None:
             show_current_and_corner_cases(case_query.case, {case_query.attribute_name: case_query.target_value},
                                           last_evaluated_rule=last_evaluated_rule)
         return self._get_conditions(case_query)
@@ -148,7 +148,8 @@ class Human(Expert):
                                                 scope=case_query.scope,
                                                  mutually_exclusive=case_query.mutually_exclusive)
         else:
-            show_current_and_corner_cases(case_query.case)
+            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)
         case_query.target = expression

ripple_down_rules/rdr.py

@@ -22,7 +22,7 @@ from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
 from .user_interface.gui import RDRCaseViewer
 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
+    is_conflicting, update_case, get_imports_from_scope, extract_function_source, extract_imports
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -41,6 +41,10 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
     """
     The name of the generated python file.
     """
+    name: Optional[str] = None
+    """
+    The name of the classifier.
+    """
 
     def __init__(self, start_rule: Optional[Rule] = None, viewer: Optional[RDRCaseViewer] = None):
         """
@@ -138,6 +142,7 @@ 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
         if case_query.target is None:
             case_query_cp = copy(case_query)
             self.classify(case_query_cp.case, modify_case=True)
@@ -237,11 +242,15 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         all_func_names = condition_func_names + conclusion_func_names
         filepath = f"{package_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)
         for rule in [self.start_rule] + list(self.start_rule.descendants):
             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:
                 rule.conclusion.user_input = functions_source[f"conclusion_{rule.uid}"]
+                rule.conclusion.scope = scope
 
     @abstractmethod
     def write_rules_as_source_code_to_file(self, rule: Rule, file, parent_indent: str = "",
@@ -275,6 +284,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
             imports += f"from .{self.generated_python_defs_file_name} import *\n"
             imports += f"from ripple_down_rules.rdr import {self.__class__.__name__}\n"
             f.write(imports + "\n\n")
+            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"type_ = {self.__class__.__name__}\n")
             f.write(f"\n\n{func_def}")
@@ -384,6 +394,31 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         return self.start_rule.conclusion_name
 
+    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}
+
+    @classmethod
+    def _from_json(cls, data: Dict[str, Any]) -> Self:
+        """
+        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)
+        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"]
+        return new_rdr
+
+    @staticmethod
+    @abstractmethod
+    def start_rule_type() -> Type[Rule]:
+        """
+        :return: The type of the starting rule of the RDR classifier.
+        """
+        pass
+
 
 class SingleClassRDR(RDRWithCodeWriter):
 
@@ -478,16 +513,12 @@ class SingleClassRDR(RDRWithCodeWriter):
             return (type(self.default_conclusion),)
         return super().conclusion_type
 
-    def _to_json(self) -> Dict[str, Any]:
-        return {"start_rule": self.start_rule.to_json()}
-
-    @classmethod
-    def _from_json(cls, data: Dict[str, Any]) -> Self:
+    @staticmethod
+    def start_rule_type() -> Type[Rule]:
         """
-        Create an instance of the class from a json
+        :return: The type of the starting rule of the RDR classifier.
         """
-        start_rule = SingleClassRule.from_json(data["start_rule"])
-        return cls(start_rule)
+        return SingleClassRule
 
 
 class MultiClassRDR(RDRWithCodeWriter):
@@ -693,16 +724,12 @@ class MultiClassRDR(RDRWithCodeWriter):
         """
         self.start_rule.alternative = MultiClassTopRule(conditions, conclusion, corner_case=corner_case)
 
-    def _to_json(self) -> Dict[str, Any]:
-        return {"start_rule": self.start_rule.to_json()}
-
-    @classmethod
-    def _from_json(cls, data: Dict[str, Any]) -> Self:
+    @staticmethod
+    def start_rule_type() -> Type[Rule]:
         """
-        Create an instance of the class from a json
+        :return: The type of the starting rule of the RDR classifier.
         """
-        start_rule = SingleClassRule.from_json(data["start_rule"])
-        return cls(start_rule)
+        return MultiClassTopRule
 
 
 class GeneralRDR(RippleDownRules):
@@ -733,15 +760,15 @@ class GeneralRDR(RippleDownRules):
         super(GeneralRDR, self).__init__(**kwargs)
         self.all_figs: List[plt.Figure] = [sr.fig for sr in self.start_rules_dict.values()]
 
-    def add_rdr(self, rdr: Union[SingleClassRDR, MultiClassRDR], attribute_name: Optional[str] = None):
+    def add_rdr(self, rdr: Union[SingleClassRDR, MultiClassRDR], case_query: Optional[CaseQuery] = None):
         """
         Add a ripple down rules classifier to the map of classifiers.
 
         :param rdr: The ripple down rules classifier to add.
-        :param attribute_name: The name of the attribute that the classifier is classifying.
+        :param case_query: The case query to add the classifier for.
         """
-        attribute_name = attribute_name if attribute_name else rdr.attribute_name
-        self.start_rules_dict[attribute_name] = rdr
+        name = case_query.attribute_name if case_query else rdr.name
+        self.start_rules_dict[name] = rdr
 
     @property
     def start_rule(self) -> Optional[Union[SingleClassRule, MultiClassTopRule]]:
@@ -825,7 +852,6 @@ class GeneralRDR(RippleDownRules):
         :param expert: The expert to ask for differentiating features as new rule conditions.
         :return: The categories that the case belongs to.
         """
-
         case_query_cp = copy(case_query)
         self.classify(case_query_cp.case, modify_case=True)
         case_query_cp.update_target_value()
@@ -843,7 +869,7 @@ class GeneralRDR(RippleDownRules):
         """
         if case_query.attribute_name not in self.start_rules_dict:
             new_rdr = self.initialize_new_rdr_for_attribute(case_query)
-            self.add_rdr(new_rdr, case_query.attribute_name)
+            self.add_rdr(new_rdr, case_query)
 
     @staticmethod
     def initialize_new_rdr_for_attribute(case_query: CaseQuery):
@@ -854,7 +880,9 @@ class GeneralRDR(RippleDownRules):
             else MultiClassRDR()
 
     def _to_json(self) -> Dict[str, Any]:
-        return {"start_rules": {t: rdr.to_json() for t, rdr in self.start_rules_dict.items()}}
+        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}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> GeneralRDR:
@@ -864,7 +892,12 @@ 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)
-        return cls(start_rules_dict)
+        new_rdr = cls(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"]
+        return new_rdr
 
     def update_from_python_file(self, package_dir: str) -> None:
         """
@@ -921,7 +954,7 @@ class GeneralRDR(RippleDownRules):
         """
         :return: The default generated python file name.
         """
-        if self.start_rule is None or self.start_rule.corner_case is None:
+        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

ripple_down_rules/rules.py

@@ -5,6 +5,7 @@ from abc import ABC, abstractmethod
 from uuid import uuid4
 
 from anytree import NodeMixin
+from rospy import logwarn, logdebug
 from sqlalchemy.orm import DeclarativeBase as SQLTable
 from typing_extensions import List, Optional, Self, Union, Dict, Any, Tuple
 
@@ -151,7 +152,8 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         json_serialization = {"conditions": self.conditions.to_json(),
                               "conclusion": conclusion_to_json(self.conclusion),
                               "parent": self.parent.json_serialization if self.parent else None,
-                              "corner_case": SubclassJSONSerializer.to_json_static(self.corner_case),
+                              "corner_case": SubclassJSONSerializer.to_json_static(self.corner_case)
+                              if self.corner_case else None,
                               "conclusion_name": self.conclusion_name,
                               "weight": self.weight,
                               "uid": self.uid}
@@ -159,10 +161,15 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Rule:
+        try:
+            corner_case = Case.from_json(data["corner_case"])
+        except Exception as e:
+            logdebug("Failed to load corner case from json, setting it to None.")
+            corner_case = None
         loaded_rule = cls(conditions=CallableExpression.from_json(data["conditions"]),
                           conclusion=CallableExpression.from_json(data["conclusion"]),
                           parent=cls.from_json(data["parent"]),
-                          corner_case=Case.from_json(data["corner_case"]),
+                          corner_case=corner_case,
                           conclusion_name=data["conclusion_name"],
                           weight=data["weight"],
                           uid=data["uid"])

ripple_down_rules/user_interface/prompt.py

@@ -134,14 +134,14 @@ class UserPrompt:
         """
         while True:
             if user_input is None:
-                if QApplication.instance() is None:
+                if self.viewer is None:
                     shell = IPythonShell() if shell is None else shell
                     shell.run()
                     user_input = shell.user_input
                 else:
                     app = QApplication.instance()
                     if app is None:
-                        app = QApplication([])
+                        raise RuntimeError("QApplication instance is None. Please run the application first.")
                     self.viewer.show()
                     app.exec()
                     user_input = self.viewer.user_input

ripple_down_rules/user_interface/template_file_creator.py

@@ -79,7 +79,7 @@ class TemplateFileCreator:
         self.case_query = case_query
         self.output_type = self.get_output_type()
         self.user_edit_line = 0
-        self.func_name: str = self.get_func_name()
+        self.func_name: str = self.get_func_name(self.prompt_for, self.case_query)
         self.func_doc: str = self.get_func_doc()
         self.function_signature: str = self.get_function_signature()
         self.editor: Optional[Editor] = detect_available_editor()
@@ -146,7 +146,7 @@ class TemplateFileCreator:
 
     def get_function_signature(self) -> str:
         if self.func_name is None:
-            self.func_name = self.get_func_name()
+            self.func_name = self.get_func_name(self.prompt_for, self.case_query)
         output_type_hint = self.get_output_type_hint()
         func_args = self.get_func_args()
         return f"def {self.func_name}({func_args}){output_type_hint}:"
@@ -238,15 +238,19 @@ class TemplateFileCreator:
         else:
             return f"Get possible value(s) for {self.case_query.name}"
 
-    def get_func_name(self) -> Optional[str]:
+    @staticmethod
+    def get_func_name(prompt_for, case_query) -> Optional[str]:
         func_name = ""
-        if self.prompt_for == PromptFor.Conditions:
-            func_name = f"{self.prompt_for.value.lower()}_for_"
-        case_name = self.case_query.name.replace(".", "_")
-        if self.case_query.is_function:
+        if prompt_for == PromptFor.Conditions:
+            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"_{self.case_query.attribute_name}", "")
+            case_name = case_name.replace(f"_{case_query.attribute_name}", "")
         func_name += case_name
+        attr_types = [t for t in case_query.core_attribute_type if t.__module__ != "builtins" and t is not None
+                      and t is not type(None)]
+        func_name += f"_of_type_{'_or_'.join(map(lambda c: c.__name__, attr_types))}"
         return str_to_snake_case(func_name)
 
     @cached_property

ripple_down_rules/utils.py

@@ -14,6 +14,7 @@ from collections import UserDict
 from copy import deepcopy, copy
 from dataclasses import is_dataclass, fields
 from enum import Enum
+from textwrap import dedent
 from types import NoneType
 
 import matplotlib
@@ -22,6 +23,7 @@ import requests
 from anytree import Node, RenderTree
 from anytree.exporter import DotExporter
 from matplotlib import pyplot as plt
+from rospy import logwarn
 from sqlalchemy import MetaData, inspect
 from sqlalchemy.orm import Mapped, registry, class_mapper, DeclarativeBase as SQLTable, Session
 from tabulate import tabulate
@@ -129,7 +131,7 @@ def extract_imports(file_path):
                     module = importlib.import_module(module_name)
                     scope[asname] = getattr(module, name)
                 except (ImportError, AttributeError) as e:
-                    print(f"Could not import {name} from {module_name}: {e}")
+                    logwarn(f"Could not import {module_name}: {e} while extracting imports from {file_path}")
 
     return scope
 
@@ -167,7 +169,7 @@ def extract_function_source(file_path: str,
             if not include_signature:
                 func_lines = func_lines[1:]
             line_numbers.append((node.lineno, node.end_lineno))
-            functions_source[node.name] = "\n".join(func_lines) if join_lines else func_lines
+            functions_source[node.name] = dedent("\n".join(func_lines)) if join_lines else func_lines
             if len(functions_source) == len(function_names):
                 break
     if len(functions_source) != len(function_names):

{ripple_down_rules-0.4.3.dist-info → ripple_down_rules-0.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.4.3
+Version: 0.4.7
 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
@@ -677,12 +677,26 @@ License:                     GNU GENERAL PUBLIC LICENSE
         the library.  If this is what you want to do, use the GNU Lesser General
         Public License instead of this License.  But first, please read
         <https://www.gnu.org/licenses/why-not-lgpl.html>.
-Project-URL: Homepage, https://github.com/AbdelrhmanBassiouny/ripple_down_rules
 Keywords: robotics,knowledge,reasoning,representation
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: anytree>=2.8.0
+Requires-Dist: pandas>=2.0.3
+Requires-Dist: networkx>=3.1
+Requires-Dist: ordered_set>=4
+Requires-Dist: pygraphviz>=1.7
+Requires-Dist: ucimlrepo>=0.0.7
+Requires-Dist: typing-extensions>=4.12.2
+Requires-Dist: matplotlib>=3.7.5
+Requires-Dist: sqlalchemy
+Requires-Dist: pyqt6
+Requires-Dist: qtconsole
+Requires-Dist: graphviz
+Requires-Dist: tabulate
+Requires-Dist: ipython
+Requires-Dist: requests
+Requires-Dist: colorama
 Dynamic: license-file
 
 # Ripple Down Rules (RDR)

{ripple_down_rules-0.4.3.dist-info → ripple_down_rules-0.4.7.dist-info}/RECORD

@@ -1,12 +1,12 @@
 ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/datasets.py,sha256=fJbZ7V-UUYTu5XVVpFinTbuzN3YePCnUB01L3AyZVM8,6837
-ripple_down_rules/experts.py,sha256=S-d1EZP0SK0Ab_pMzgkOcLvZFLMdSm8_C0u3AgfouUc,6468
+ripple_down_rules/experts.py,sha256=dEZKv58sdicDByj0T0bu0q6coIBMce6o4t9gJICQy1k,6556
 ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
 ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
-ripple_down_rules/rdr.py,sha256=cO5QUtrKDaOk75GUnBwxzq-ZYzFbJhgycX6BKeLEVtM,44258
+ripple_down_rules/rdr.py,sha256=jxMvkyQ_2jdyxa5aKmvGRHvD-IJBKjsyOpxvvJbFLPE,45518
 ripple_down_rules/rdr_decorators.py,sha256=VdmE0JrE8j89b6Af1R1tLZiKfy3h1VCvhAUefN_FLLQ,6753
-ripple_down_rules/rules.py,sha256=QQy7NBG6mKiowxVG_LjQJBxLTDW2hMyx5zAgwUxdCMM,17183
-ripple_down_rules/utils.py,sha256=kJEqmKuq3NxM8gY7MrXSps2Xvf1FsYFgTMo3PSYZJY8,49098
+ripple_down_rules/rules.py,sha256=PLNaRLn5tQbq7gNsAe-n9hTjKC80p_7MbfkZWgDxLBg,17474
+ripple_down_rules/utils.py,sha256=3x6BHCoqEewn40lDtUIWOMQLZ_IA0j7WnY9_YDHvs-o,49192
 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=oC8OSdhXvHE-Zx1IIQlad-fsKzQQqr6MZBW24c-dbeU,15191
@@ -16,10 +16,10 @@ ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRk
 ripple_down_rules/user_interface/gui.py,sha256=GlVUYGpMRikrd-FjYCAamdKFAuTAeiq21ZzQvjVKJ4g,27588
 ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=tc7ms80iPNElm9AYC6i1FlfMKkqHLT8wmOEXg_k9yAU,6275
 ripple_down_rules/user_interface/object_diagram.py,sha256=84JlEH0nQmtGmP8Su5iRX3ZfqByYHbVwd0BQYYPuckY,4436
-ripple_down_rules/user_interface/prompt.py,sha256=tQyIrRno1YuS3K0c4p48FVTdDJGG0HCE63WHVKpSJ1I,7976
-ripple_down_rules/user_interface/template_file_creator.py,sha256=PegwW_g8UScjEF2GGe1eV0VoWUzxPhA27L9ExbL7Y_E,12610
-ripple_down_rules-0.4.3.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.4.3.dist-info/METADATA,sha256=gT-m0t8DxQkY2a7qqne4CxS-6WnobM0LGBa4dBlMOwo,42875
-ripple_down_rules-0.4.3.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-ripple_down_rules-0.4.3.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.4.3.dist-info/RECORD,,
+ripple_down_rules/user_interface/prompt.py,sha256=97s5mhmsqrFTQkfmHssYFko0SPLBDxesHoLumqZO0FA,8028
+ripple_down_rules/user_interface/template_file_creator.py,sha256=_CEe8H07q62YpImy1p72vXcPHkJ2_Q0n6t56K6g2gPE,12930
+ripple_down_rules-0.4.7.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.4.7.dist-info/METADATA,sha256=NOxEaLxlUHlfwCGv9lgu_083JZl3ls6fcknejdagcm0,43217
+ripple_down_rules-0.4.7.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+ripple_down_rules-0.4.7.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.4.7.dist-info/RECORD,,