ripple-down-rules 0.6.13__py3-none-any.whl → 0.6.15__py3-none-any.whl

ripple_down_rules/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.13"
+__version__ = "0.6.15"
 
 import logging
 logger = logging.Logger("rdr")

ripple_down_rules/datastructures/callable_expression.py

@@ -116,6 +116,10 @@ class CallableExpression(SubclassJSONSerializer):
         if user_input is None:
             user_input = build_user_input_from_conclusion(conclusion)
         self.conclusion: Optional[Any] = conclusion
+        if "def " in user_input:
+            self.user_defined_name = user_input.split('(')[0].replace('def ', '')
+        else:
+            self.user_defined_name = user_input
         self._user_input: str = encapsulate_user_input(user_input, self.get_encapsulating_function())
         if conclusion_type is not None:
             if is_iterable(conclusion_type):
@@ -214,6 +218,10 @@ class CallableExpression(SubclassJSONSerializer):
         Set the user input.
         """
         if value is not None:
+            if "def " in value:
+                self.user_defined_name = value.split('(')[0].replace('def ', '')
+            else:
+                self.user_defined_name = value
             self._user_input = encapsulate_user_input(value, self.get_encapsulating_function())
             self.scope = get_used_scope(self.user_input, self.scope)
             self.expression_tree = parse_string_to_expression(self.user_input)

ripple_down_rules/helpers.py

@@ -55,7 +55,7 @@ def general_rdr_classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDow
             if attribute_name in new_conclusions:
                 temp_case_query = CaseQuery(case_cp, attribute_name, rdr.conclusion_type, rdr.mutually_exclusive)
                 update_case(temp_case_query, new_conclusions)
-        if len(new_conclusions) == 0 or len(classifiers_dict) == 1:
+        if len(new_conclusions) == 0 or len(classifiers_dict) == 1 and list(classifiers_dict.values())[0].mutually_exclusive:
             break
     return conclusions
 

ripple_down_rules/rdr.py

@@ -36,7 +36,7 @@ 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_iterable, str_to_snake_case, get_import_path_from_path, get_imports_from_types, render_tree
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -92,8 +92,38 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         self.start_rule = start_rule
         self.fig: Optional[Figure] = None
         self.viewer: Optional[RDRCaseViewer] = viewer
-        if self.viewer is not None:
-            self.viewer.set_save_function(self.save)
+        if viewer is None:
+            if len(RDRCaseViewer.instances) > 0:
+                self.viewer = RDRCaseViewer.instances[0]
+                logger.error("No viewer was provided, but there is already an existing viewer. "
+                             "Using the existing viewer.")
+
+    @property
+    def viewer(self):
+        return self._viewer
+    
+    @viewer.setter
+    def viewer(self, value):
+        self._viewer = value
+        if value is not None:
+            value.set_save_function(self.save)
+
+    def render_evaluated_rule_tree(self, filename: str) -> None:
+        evaluated_rules = self.get_evaluated_rule_tree()
+        if len(evaluated_rules) > 0:
+            render_tree(evaluated_rules[0], use_dot_exporter=True, filename=filename,
+                        only_nodes=evaluated_rules)
+
+    def get_evaluated_rule_tree(self) -> List[Rule]:
+        """
+        Get the evaluated rule tree of the classifier.
+
+        :return: The evaluated rule tree.
+        """
+        if self.start_rule is None:
+            raise ValueError("The start rule is not set. Please set the start rule before getting the evaluated rule tree.")
+        evaluated_rule_tree = [r for r in [self.start_rule] + list(self.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:

ripple_down_rules/rdr_decorators.py

@@ -33,7 +33,7 @@ class RDRDecorator:
                  viewer: Optional[RDRCaseViewer] = None,
                  package_name: Optional[str] = None,
                  use_generated_classifier: bool = False,
-                 ask_now: Callable[[Any, Any], bool] = lambda _,n: True,
+                 ask_now: Callable[Dict[str, Any], bool] = lambda _: True,
                  fitting_decorator: Optional[Callable] = None):
         """
         :param models_dir: The directory to save/load the RDR models.
@@ -67,7 +67,8 @@ class RDRDecorator:
         self.use_generated_classifier = use_generated_classifier
         self.generated_classifier: Optional[Callable] = None
         self.ask_now = ask_now
-        self.fitting_decorator = fitting_decorator
+        self.fitting_decorator = fitting_decorator if fitting_decorator is not None else \
+            lambda f: f  # Default to no fitting decorator
         self.load()
 
     def decorator(self, func: Callable) -> Callable:
@@ -99,7 +100,7 @@ class RDRDecorator:
                                            viewer=self.viewer)
                 return output
             
-            if self.fit and not self.use_generated_classifier and self.ask_now(case_dict, self.rdr.classify(case)):
+            if self.fit and not self.use_generated_classifier and self.ask_now(case_dict):
                 output = fit()
             else:
                 if self.use_generated_classifier:
@@ -167,6 +168,7 @@ class RDRDecorator:
         return Case(dict, id(case_dict), case_name, case_dict, **case_dict), case_dict
 
     def initialize_rdr_model_name_and_load(self, func: Callable) -> None:
+        self.viewer = RDRCaseViewer.instances[0] if len(RDRCaseViewer.instances) > 0 else self.viewer
         model_file_name = get_func_rdr_model_name(func, include_file_name=True)
         self.model_name = str_to_snake_case(model_file_name)
         self.load()
@@ -201,10 +203,8 @@ class RDRDecorator:
             model_path = os.path.join(self.rdr_models_dir, self.model_name + f"/rdr_metadata/{self.model_name}.json")
             if os.path.exists(os.path.join(self.rdr_models_dir, model_path)):
                 self.rdr = GeneralRDR.load(self.rdr_models_dir, self.model_name, package_name=self.package_name)
-                self.rdr.set_viewer(self.viewer)
         if self.rdr is None:
-            self.rdr = GeneralRDR(save_dir=self.rdr_models_dir, model_name=self.model_name,
-                                  viewer=self.viewer)
+            self.rdr = GeneralRDR(save_dir=self.rdr_models_dir, model_name=self.model_name)
 
     def update_from_python(self):
         """

ripple_down_rules/rules.py

@@ -57,6 +57,21 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         self._name: Optional[str] = None
         # generate a unique id for the rule using uuid4
         self.uid: str = uid if uid else str(uuid4().int)
+        self.evaluated: bool = False
+        self._user_defined_name: Optional[str] = None
+
+    @property
+    def user_defined_name(self) -> Optional[str]:
+        """
+        Get the user defined name of the rule, if it exists.
+        """
+        if self._user_defined_name is None:
+            if self.conditions and self.conditions.user_input and "def " in self.conditions.user_input:
+                # If the conditions have a user input, use it as the name
+                self._user_defined_name = self.conditions.user_input.split('(')[0].replace('def ', '').strip()
+            else:
+                self._user_defined_name = f"Rule_{self.uid}"
+        return self._user_defined_name
 
     @classmethod
     def from_case_query(cls, case_query: CaseQuery) -> Rule:
@@ -91,6 +106,10 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         :param x: The case to evaluate the rule on.
         :return: The rule that fired or the last evaluated rule if no rule fired.
         """
+        if self.root is self:
+            for descendant in self.descendants:
+                descendant.evaluated = False
+        self.evaluated = True
         if not self.conditions:
             raise ValueError("Rule has no conditions")
         self.fired = self.conditions(x)
@@ -261,11 +280,40 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         """
         self._name = new_name
 
+    @property
+    def semantic_condition_name(self) -> Optional[str]:
+        """
+        Get the name of the conditions of the rule, which is the user input of the conditions.
+        """
+        return self.expression_name(self.conditions)
+
+    @property
+    def semantic_conclusion_name(self) -> Optional[str]:
+        """
+        Get the name of the conclusion of the rule, which is the user input of the conclusion.
+        """
+        return self.expression_name(self.conclusion)
+
+    @staticmethod
+    def expression_name(expression: CallableExpression) -> str:
+        """
+        Get the name of the expression, which is the user input of the expression if it exists,
+        otherwise it is the conclusion or conditions of the rule.
+        """
+        if expression.user_defined_name is not None:
+            return expression.user_defined_name.strip()
+        elif expression.user_input and "def " in expression.user_input:
+            return expression.user_input.split('(')[0].replace('def ', '').strip()
+        elif expression.user_input:
+            return expression.user_input.strip()
+        else:
+            return str(expression)
+
     def __str__(self, sep="\n"):
         """
         Get the string representation of the rule, which is the conditions and the conclusion.
         """
-        return f"{self.conditions}{sep}=> {self.conclusion}"
+        return f"{self.semantic_condition_name}{sep}=> {self.semantic_conclusion_name}"
 
     def __repr__(self):
         return self.__str__()

ripple_down_rules/user_interface/gui.py

@@ -282,11 +282,14 @@ class RDRCaseViewer(QMainWindow):
     user_input: Optional[str] = None
     attributes_widget: Optional[QWidget] = None
     save_function: Optional[Callable[str, str], None] = None
+    instances: List[RDRCaseViewer] = []
 
     def __init__(self, parent=None,
                  save_dir: Optional[str] = None,
                  save_model_name: Optional[str] = None):
         super().__init__(parent)
+        self.instances.clear()
+        self.instances.append(self)
         self.save_dir = save_dir
         self.save_model_name = save_model_name
 

ripple_down_rules/utils.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import ast
 import builtins
 import copyreg
 import importlib
@@ -22,10 +21,10 @@ from types import NoneType
 
 from sqlalchemy.exc import NoInspectionAvailable
 
-
 try:
     import matplotlib
     from matplotlib import pyplot as plt
+
     Figure = plt.Figure
 except ImportError as e:
     matplotlib = None
@@ -40,13 +39,13 @@ except ImportError as e:
     logging.debug(f"{e}: networkx is not installed")
 
 import requests
-from anytree import Node, RenderTree
+from anytree import Node, RenderTree, PreOrderIter
 from anytree.exporter import DotExporter
 from sqlalchemy import MetaData, inspect
 from sqlalchemy.orm import Mapped, registry, class_mapper, DeclarativeBase as SQLTable, Session
 from tabulate import tabulate
 from typing_extensions import Callable, Set, Any, Type, Dict, TYPE_CHECKING, get_type_hints, \
-    get_origin, get_args, Tuple, Optional, List, Union, Self, ForwardRef, Sequence, Iterable
+    get_origin, get_args, Tuple, Optional, List, Union, Self, ForwardRef, Iterable
 
 if TYPE_CHECKING:
     from .datastructures.case import Case
@@ -127,7 +126,7 @@ def extract_imports(file_path: Optional[str] = None, tree: Optional[ast.AST] = N
                 name = alias.name
                 asname = alias.asname or name
                 try:
-                    if package_name is not None and node.level > 0: # Handle relative imports
+                    if package_name is not None and node.level > 0:  # Handle relative imports
                         module_rel_path = Path(os.path.join(file_path, *['..'] * node.level, module_name)).resolve()
                         idx = str(module_rel_path).rfind(package_name)
                         if idx != -1:
@@ -681,6 +680,7 @@ def is_builtin_type(tp):
 def is_typing_type(tp):
     return tp.__module__ == "typing"
 
+
 origin_type_to_hint = {
     list: List,
     set: Set,
@@ -688,6 +688,7 @@ origin_type_to_hint = {
     tuple: Tuple,
 }
 
+
 def extract_types(tp, seen: Set = None) -> Set[type]:
     """Recursively extract all base types from a type hint."""
     if seen is None:
@@ -1400,7 +1401,8 @@ def table_rows_as_str(row_dicts: List[Dict[str, Any]], columns_per_row: int = 20
     keys_values = [list(r[0]) + list(r[1]) if len(r) > 1 else r[0] for r in keys_values]
     all_table_rows = []
     row_values = [list(map(lambda v: str(v) if v is not None else "", row)) for row in keys_values]
-    row_values = [list(map(lambda v: v[:max_line_sze] + '...' if len(v) > max_line_sze else v, row)) for row in row_values]
+    row_values = [list(map(lambda v: v[:max_line_sze] + '...' if len(v) > max_line_sze else v, row)) for row in
+                  row_values]
     row_values = [list(map(lambda v: v.lower() if v in ["True", "False"] else v, row)) for row in row_values]
     table = tabulate(row_values, tablefmt='simple_grid', maxcolwidths=[max_line_sze] * 2)
     all_table_rows.append(table)
@@ -1627,14 +1629,46 @@ def edge_attr_setter(parent, child):
     return ""
 
 
+class FilteredDotExporter(DotExporter):
+    def __init__(self, root, include_nodes=None, **kwargs):
+        self.include_nodes = include_nodes
+        node_name_func = get_unique_node_names_func(root)
+        self.include_node_names = [node_name_func(n) for n in self.include_nodes] if include_nodes else None
+        super().__init__(root, **kwargs)
+
+    def __iter_nodes(self, indent, nodenamefunc, nodeattrfunc):
+        for node in PreOrderIter(self.node, maxlevel=self.maxlevel):
+            nodename = nodenamefunc(node)
+            if self.include_nodes is not None and nodename not in self.include_node_names:
+                continue
+            nodeattr = nodeattrfunc(node)
+            nodeattr = " [%s]" % nodeattr if nodeattr is not None else ""
+            yield '%s"%s"%s;' % (indent, DotExporter.esc(nodename), nodeattr)
+
+    def __iter_edges(self, indent, nodenamefunc, edgeattrfunc, edgetypefunc):
+        maxlevel = self.maxlevel - 1 if self.maxlevel else None
+        for node in PreOrderIter(self.node, maxlevel=maxlevel):
+            nodename = nodenamefunc(node)
+            if self.include_nodes is not None and nodename not in self.include_node_names:
+                continue
+            for child in node.children:
+                childname = nodenamefunc(child)
+                edgeattr = edgeattrfunc(node, child)
+                edgetype = edgetypefunc(node, child)
+                edgeattr = " [%s]" % edgeattr if edgeattr is not None else ""
+                yield '%s"%s" %s "%s"%s;' % (indent, DotExporter.esc(nodename), edgetype,
+                                             DotExporter.esc(childname), edgeattr)
+
+
 def render_tree(root: Node, use_dot_exporter: bool = False,
-                filename: str = "scrdr"):
+                filename: str = "scrdr", only_nodes: List[Node] = None):
     """
     Render the tree using the console and optionally export it to a dot file.
 
     :param root: The root node of the tree.
     :param use_dot_exporter: Whether to export the tree to a dot file.
     :param filename: The name of the file to export the tree to.
+    :param only_nodes: A list of nodes to include in the dot export.
     """
     if not root:
         logging.warning("No rules to render")
@@ -1644,10 +1678,11 @@ def render_tree(root: Node, use_dot_exporter: bool = False,
     if use_dot_exporter:
         unique_node_names = get_unique_node_names_func(root)
 
-        de = DotExporter(root,
-                         nodenamefunc=unique_node_names,
-                         edgeattrfunc=edge_attr_setter
-                         )
+        de = FilteredDotExporter(root,
+                                 include_nodes=only_nodes,
+                                 nodenamefunc=unique_node_names,
+                                 edgeattrfunc=edge_attr_setter
+                                 )
         de.to_dotfile(f"{filename}{'.dot'}")
         de.to_picture(f"{filename}{'.png'}")
 

{ripple_down_rules-0.6.13.dist-info → ripple_down_rules-0.6.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.13
+Version: 0.6.15
 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,6 +677,7 @@ 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
 Description-Content-Type: text/markdown

{ripple_down_rules-0.6.13.dist-info → ripple_down_rules-0.6.15.dist-info}/RECORD

@@ -1,24 +1,24 @@
-ripple_down_rules/__init__.py,sha256=bHNnB4r5WRrjFPnOG4ulZdsLVSJHg3xarT5y9_woJ1A,100
+ripple_down_rules/__init__.py,sha256=lX1XrdZ7llw3tZk6e_RhQszLZMG9KS8H7GA6V7n4DlI,100
 ripple_down_rules/experts.py,sha256=4-dMIVeMzFXCLYl_XBG_P7_Xs4sZih9-vZxCIPri6dA,12958
-ripple_down_rules/helpers.py,sha256=X-pYuCsmuNraUFcIL450AsaOdGvGjotNPgSx8yu3NMg,4525
-ripple_down_rules/rdr.py,sha256=I6NRZuXR_1lyWOHkN34HiLA-7dg-OLWEnHodKVjYTQI,56331
-ripple_down_rules/rdr_decorators.py,sha256=SZ2ivGtT_2xuoGlTE9PtjqdC02AqZXkLh-MhgBBPcfw,10632
-ripple_down_rules/rules.py,sha256=Dk4yGCy5oV10mOv5rRLcmtIu9J60WBPol9b7ELFn6fY,21522
+ripple_down_rules/helpers.py,sha256=RUdfiSWMZjGwCxuCy44TcEJf2UNAFlPJusgHzuAs6qI,4583
+ripple_down_rules/rdr.py,sha256=mtY_kBOjUXRZYz4QFaKN6C2O7liFpbMdnjUnFFnXbdU,57550
+ripple_down_rules/rdr_decorators.py,sha256=j_bIv30nonWz-D5em7dYnV3htlklar2QwFRa5o48XYM,10707
+ripple_down_rules/rules.py,sha256=ULIHRbVfKd2L3zzPnssmaeqInWHifPvwwa16MyzakPc,23548
 ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=vFoz5HcRgkf7_s-zdWSg54xI9PCMcdDzcdFGdas7KBA,62350
+ripple_down_rules/utils.py,sha256=uOa_b3FoDnoTLp84RnMbeSyiTMgREtUOkOImQj8B5HQ,64204
 ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
-ripple_down_rules/datastructures/callable_expression.py,sha256=pslqv9igc7d6s1TCKdJSfIdU98_L1BPKNmfLVlGdGHs,12965
+ripple_down_rules/datastructures/callable_expression.py,sha256=ysK-4JmZ4oSUTJC7zpo_o77g4ONxPDEcIpSWggsnx3c,13320
 ripple_down_rules/datastructures/case.py,sha256=PJ7_-AdxYic6BO5z816piFODj6nU5J6Jt1YzTFH-dds,15510
 ripple_down_rules/datastructures/dataclasses.py,sha256=D-nrVEW_27njmDGkyiHRnq5lmqEdO8RHKnLb1mdnwrA,11054
 ripple_down_rules/datastructures/enums.py,sha256=ce7tqS0otfSTNAOwsnXlhsvIn4iW_Y_N3TNebF3YoZs,5700
 ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules/user_interface/gui.py,sha256=_lgZAUXxxaBUFQJAHjA5TBPp6XEvJ62t-kSN8sPsocE,27379
+ripple_down_rules/user_interface/gui.py,sha256=druufu9cVeVUajPW-RqGW3ZiEbgdgNBQD2CLhadQo18,27486
 ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=yp-F8YRWGhj1PLB33HE6vJkdYWFN5Zn2244S2DUWRTM,6576
 ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
 ripple_down_rules/user_interface/prompt.py,sha256=JceEUGYsd0lIvd-v2y3D3swoo96_C0lxfp3CxM7Vfts,8900
 ripple_down_rules/user_interface/template_file_creator.py,sha256=kwBbFLyN6Yx2NTIHPSwOoytWgbJDYhgrUOVFw_jkDQ4,13522
-ripple_down_rules-0.6.13.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.6.13.dist-info/METADATA,sha256=paDmKM4LPfXdduNun6UH8pEn7XgdnWHuyY_Xi4bpDt8,48214
-ripple_down_rules-0.6.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ripple_down_rules-0.6.13.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.6.13.dist-info/RECORD,,
+ripple_down_rules-0.6.15.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.6.15.dist-info/METADATA,sha256=2x_pdEry-CrkjQ1lgQXmfGhjdK5HScMZOSf16a_yUfE,48294
+ripple_down_rules-0.6.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.6.15.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.6.15.dist-info/RECORD,,