ripple-down-rules 0.6.23__tar.gz → 0.6.24__tar.gz

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.23
+Version: 0.6.24
 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

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/scripts/live_dot_server_client.py

@@ -52,7 +52,7 @@ def generate_html(dot_output="graph.html"):
     }}
 
     fetchAndRender();
-    setInterval(fetchAndRender, 500);  // Refresh every 2 seconds
+    setInterval(fetchAndRender, 100);  // Refresh every 2 seconds
   </script>
 </body>
 </html>"""

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/src/ripple_down_rules/__init__.py

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

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/src/ripple_down_rules/rdr.py

@@ -4,7 +4,9 @@ import importlib
 import os
 from abc import ABC, abstractmethod
 from copy import copy
+from dataclasses import is_dataclass
 from types import NoneType
+import json
 
 from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
 from . import logger
@@ -36,7 +38,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, render_tree
+    is_iterable, str_to_snake_case, get_import_path_from_path, get_imports_from_types, render_tree, table_rows_as_str
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -97,11 +99,12 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                 self.viewer = RDRCaseViewer.instances[0]
                 logger.error("No viewer was provided, but there is already an existing viewer. "
                              "Using the existing viewer.")
+        self.input_node: Optional[Rule] = None
 
     @property
     def viewer(self):
         return self._viewer
-    
+
     @viewer.setter
     def viewer(self, value):
         self._viewer = value
@@ -110,23 +113,24 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
     def render_evaluated_rule_tree(self, filename: str, show_full_tree: bool = False) -> None:
         if show_full_tree:
-            render_tree(self.start_rule, use_dot_exporter=True, filename=filename)
+            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_evaluated_rule_tree(self) -> List[Rule]:
+    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
-            # 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 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,
@@ -260,9 +264,38 @@ 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.evaluated = False
+                rule.fired = False
+        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 = ""
+        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.
@@ -703,8 +736,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.
 
@@ -818,8 +851,8 @@ 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]:
+    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:
@@ -1064,8 +1097,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.

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/src/ripple_down_rules/rdr_decorators.py

@@ -8,15 +8,16 @@ from functools import wraps
 
 from typing_extensions import Callable, Optional, Type, Tuple, Dict, Any, Self, get_type_hints, List, Union, Sequence
 
-from ripple_down_rules.datastructures.case import Case
-from ripple_down_rules.datastructures.dataclasses import CaseQuery
-from ripple_down_rules.experts import Expert, Human
-from ripple_down_rules.rdr import GeneralRDR
+from .datastructures.case import Case
+from .datastructures.dataclasses import CaseQuery
+from .experts import Expert, Human
+from .rdr import GeneralRDR
+from . import logger
 try:
-    from ripple_down_rules.user_interface.gui import RDRCaseViewer
+    from .user_interface.gui import RDRCaseViewer
 except ImportError:
     RDRCaseViewer = None
-from ripple_down_rules.utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
+from .utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
     get_method_class_if_exists, str_to_snake_case
 
 

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/src/ripple_down_rules/rules.py

@@ -116,9 +116,6 @@ 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")

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/src/ripple_down_rules/utils.py

@@ -21,6 +21,7 @@ from subprocess import check_call
 from tempfile import NamedTemporaryFile
 from textwrap import dedent
 from types import NoneType
+import shutil
 
 import six
 from sqlalchemy.exc import NoInspectionAvailable
@@ -50,6 +51,7 @@ from sqlalchemy.orm import Mapped, registry, class_mapper, DeclarativeBase as SQ
 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, Iterable
+from . import logger
 
 if TYPE_CHECKING:
     from .datastructures.case import Case
@@ -1408,7 +1410,11 @@ def table_rows_as_str(row_dicts: List[Dict[str, Any]], columns_per_row: int = 20
     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)
+    # Step 1: Get terminal size
+    terminal_width = shutil.get_terminal_size((80, 20)).columns
+    # Step 2: Dynamically calculate max width per column (simple approximation)
+    max_col_width = terminal_width // len(row_values[0])
+    table = tabulate(row_values, tablefmt='simple_grid', maxcolwidths=max_col_width)#[max_line_sze] * 2)
     all_table_rows.append(table)
     return "\n".join(all_table_rows)
 
@@ -1628,7 +1634,7 @@ def edge_attr_setter(parent, child):
     """
     Set the edge attributes for the dot exporter.
     """
-    if child and hasattr(child, "weight") and child.weight:
+    if child and hasattr(child, "weight") and child.weight is not None:
         return f'style="bold", label=" {child.weight}"'
     return ""
 
@@ -1913,7 +1919,7 @@ class FilteredDotExporter(object):
 
 
 def render_tree(root: Node, use_dot_exporter: bool = False,
-                filename: str = "scrdr", only_nodes: List[Node] = None):
+                filename: str = "scrdr", only_nodes: List[Node] = None, show_in_console: bool = False):
     """
     Render the tree using the console and optionally export it to a dot file.
 
@@ -1921,12 +1927,16 @@ def render_tree(root: Node, use_dot_exporter: bool = False,
     :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.
+    :param show_in_console: Whether to print the tree to the console.
     """
     if not root:
-        logging.warning("No rules to render")
+        logger.warning("No rules to render")
         return
-    # for pre, _, node in RenderTree(root):
-    #     print(f"{pre}{node.weight if hasattr(node, 'weight') and node.weight else ''} {node.__str__()}")
+    if show_in_console:
+        for pre, _, node in RenderTree(root):
+            if only_nodes is not None and node not in only_nodes:
+                continue
+            print(f"{pre}{node.weight if hasattr(node, 'weight') and node.weight else ''} {node.__str__()}")
     if use_dot_exporter:
         unique_node_names = get_unique_node_names_func(root)
 

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.6.23
+Version: 0.6.24
 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

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/test/test_results/datasets_physical_object_is_a_robot/rdr_metadata/datasets_physical_object_is_a_robot.json

@@ -55,7 +55,7 @@
                     "_name": "PhysicalObject_is_a_robot"
                 },
                 "conclusion_name": "output_",
-                "weight": null,
+                "weight": "",
                 "uid": "226969243620390858682731042391766665817",
                 "refinement": null,
                 "alternative": null

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/physical_object_select_objects_that_are_parts_of_robot_output__mcrdr.py

@@ -5,7 +5,7 @@ from .physical_object_select_objects_that_are_parts_of_robot_output__mcrdr_defs
 
 
 attribute_name = 'output_'
-conclusion_type = (set, list, PhysicalObject,)
+conclusion_type = (set, PhysicalObject, list,)
 mutually_exclusive = False
 
 

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/rdr_metadata/datasets_physical_object_select_objects_that_are_parts_of_robot.json

@@ -64,7 +64,7 @@
                     "_name": "PhysicalObject_select_objects_that_are_parts_of_robot"
                 },
                 "conclusion_name": "output_",
-                "weight": "next",
+                "weight": "",
                 "uid": "164855806603893754507167918997373216146",
                 "refinement": null,
                 "alternative": null

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/test/test_results/datasets_physical_object_is_a_robot/physical_object_is_a_robot_rdr.py

@@ -1,6 +1,6 @@
+from ripple_down_rules.datastructures.case import Case, create_case
 from ripple_down_rules.helpers import general_rdr_classify
 from typing_extensions import Any, Dict
-from ripple_down_rules.datastructures.case import Case, create_case
 from . import physical_object_is_a_robot_output__scrdr as output__classifier
 
 classifiers_dict = dict()

{ripple_down_rules-0.6.23 → ripple_down_rules-0.6.24}/test/test_results/datasets_physical_object_select_objects_that_are_parts_of_robot/physical_object_select_objects_that_are_parts_of_robot_rdr.py

@@ -1,6 +1,6 @@
+from ripple_down_rules.datastructures.case import Case, create_case
 from ripple_down_rules.helpers import general_rdr_classify
 from typing_extensions import Any, Dict
-from ripple_down_rules.datastructures.case import Case, create_case
 from . import physical_object_select_objects_that_are_parts_of_robot_output__mcrdr as output__classifier
 
 classifiers_dict = dict()