ripple-down-rules 0.1.66__tar.gz → 0.1.67__tar.gz

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.66
+Version: 0.1.67
 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.1.66 → ripple_down_rules-0.1.67}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.66"
+version = "0.1.67"
 description = "Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning."
 readme = "README.md"
 authors = [{ name = "Abdelrhman Bassiouny", email = "abassiou@uni-bremen.de" }]

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.67}/src/ripple_down_rules/datasets.py

@@ -125,7 +125,7 @@ class HabitatTable(MappedAsDataclass, Base):
         return hash(self.habitat)
 
     def __str__(self):
-        return self.habitat.value
+        return f"{HabitatTable.__name__}({Habitat.__name__}.{self.habitat.name})"
 
     def __repr__(self):
         return self.__str__()

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.67}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -3,11 +3,13 @@ from __future__ import annotations
 import ast
 import logging
 from _ast import AST
+from enum import Enum
 
 from typing_extensions import Type, Optional, Any, List, Union, Tuple, Dict, Set
 
 from .case import create_case, Case
-from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string, conclusion_to_json, is_iterable
+from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string, conclusion_to_json, is_iterable, \
+    build_user_input_from_conclusion, encapsulate_user_input
 
 
 class VariableVisitor(ast.NodeVisitor):
@@ -88,6 +90,7 @@ class CallableExpression(SubclassJSONSerializer):
     """
     A callable that is constructed from a string statement written by an expert.
     """
+    encapsulating_function: str = "def _get_value(case):"
 
     def __init__(self, user_input: Optional[str] = None, conclusion_type: Optional[Tuple[Type]] = None,
                  expression_tree: Optional[AST] = None,
@@ -103,8 +106,10 @@ class CallableExpression(SubclassJSONSerializer):
         """
         if user_input is None and conclusion is None:
             raise ValueError("Either user_input or conclusion must be provided.")
+        if user_input is None:
+            user_input = build_user_input_from_conclusion(conclusion)
         self.conclusion: Optional[Any] = conclusion
-        self.user_input: str = user_input
+        self.user_input: str = encapsulate_user_input(user_input, self.encapsulating_function)
         if conclusion_type is not None:
             if is_iterable(conclusion_type):
                 conclusion_type = tuple(conclusion_type)
@@ -112,12 +117,11 @@ class CallableExpression(SubclassJSONSerializer):
                 conclusion_type = (conclusion_type,)
         self.conclusion_type = conclusion_type
         self.scope: Optional[Dict[str, Any]] = scope if scope is not None else {}
-        if conclusion is None:
-            self.scope = get_used_scope(self.user_input, self.scope)
-            self.expression_tree: AST = expression_tree if expression_tree else parse_string_to_expression(self.user_input)
-            self.code = compile_expression_to_code(self.expression_tree)
-            self.visitor = VariableVisitor()
-            self.visitor.visit(self.expression_tree)
+        self.scope = get_used_scope(self.user_input, self.scope)
+        self.expression_tree: AST = expression_tree if expression_tree else parse_string_to_expression(self.user_input)
+        self.code = compile_expression_to_code(self.expression_tree)
+        self.visitor = VariableVisitor()
+        self.visitor.visit(self.expression_tree)
 
     def __call__(self, case: Any, **kwargs) -> Any:
         try:
@@ -145,7 +149,11 @@ class CallableExpression(SubclassJSONSerializer):
         """
         Combine this callable expression with another callable expression using the 'and' operator.
         """
-        new_user_input = f"({self.user_input}) and ({other.user_input})"
+        cond1_user_input = self.user_input.replace(self.encapsulating_function, "def _cond1(case):")
+        cond2_user_input = other.user_input.replace(self.encapsulating_function, "def _cond2(case):")
+        new_user_input = (f"{cond1_user_input}\n"
+                          f"{cond2_user_input}\n"
+                          f"return _cond1(case) and _cond2(case)")
         return CallableExpression(new_user_input, conclusion_type=self.conclusion_type)
 
     def __eq__(self, other):

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.67}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -120,7 +120,7 @@ class CaseQuery:
         """
         :return: The target expression of the attribute.
         """
-        if self._target is not None and not isinstance(self._target, CallableExpression):
+        if (self._target is not None) and (not isinstance(self._target, CallableExpression)):
             self._target = CallableExpression(conclusion=self._target, conclusion_type=self.attribute_type,
                                               scope=self.scope)
         return self._target

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.67}/src/ripple_down_rules/prompt.py

@@ -80,16 +80,10 @@ class IPythonShell:
             self.user_input = None
         else:
             self.all_code_lines = extract_dependencies(self.shell.all_lines)
-            if len(self.all_code_lines) == 1:
-                if self.all_code_lines[0].strip() == '':
-                    self.user_input = None
-                else:
-                    self.user_input = self.all_code_lines[0].replace('return', '').strip()
+            if len(self.all_code_lines) == 1 and self.all_code_lines[0].strip() == '':
+                self.user_input = None
             else:
-                self.user_input = f"def _get_value(case):\n    "
-                for cl in self.all_code_lines:
-                    sub_code_lines = cl.split('\n')
-                    self.user_input += '\n    '.join(sub_code_lines) + '\n    '
+                self.user_input = '\n'.join(self.all_code_lines)
 
 
 def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, prompt_str: Optional[str] = None)\

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.67}/src/ripple_down_rules/rdr.py

@@ -715,7 +715,7 @@ class GeneralRDR(RippleDownRules):
 
     @staticmethod
     def _classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDownRules]],
-                  case: Any, modify_original_case: bool = True) -> Dict[str, Any]:
+                  case: Any, modify_original_case: bool = False) -> Dict[str, Any]:
         """
         Classify a case by going through all classifiers and adding the categories that are classified,
          and then restarting the classification until no more categories can be added.

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.67}/src/ripple_down_rules/rules.py

@@ -270,11 +270,11 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
 
     def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[Optional[str], str]:
         conclusion = str(conclusion)
-        indent = parent_indent + " " * 4
-        if '\n' not in conclusion:
-            return None, f"{indent}return {conclusion}\n"
-        else:
-            return get_rule_conclusion_as_source_code(self, conclusion, parent_indent=parent_indent)
+        # indent = parent_indent + " " * 4
+        # if '\n' not in conclusion:
+        #     return None, f"{indent}return {conclusion}\n"
+        # else:
+        return get_rule_conclusion_as_source_code(self, conclusion, parent_indent=parent_indent)
 
     def _if_statement_source_code_clause(self) -> str:
         return "elif" if self.weight == RDREdge.Alternative.value else "if"
@@ -367,15 +367,15 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
     def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[str, str]:
         conclusion_str = str(conclusion)
         indent = parent_indent + " " * 4
-        if '\n' not in conclusion_str:
-            func = None
-            if is_iterable(conclusion):
-                conclusion_str = "{" + ", ".join([str(c) for c in conclusion]) + "}"
-            else:
-                conclusion_str = "{" + str(conclusion) + "}"
-        else:
-            func, func_call = get_rule_conclusion_as_source_code(self, conclusion_str, parent_indent=parent_indent)
-            conclusion_str = func_call.replace("return ", "").strip()
+        # if '\n' not in conclusion_str:
+        #     func = None
+        #     if is_iterable(conclusion):
+        #         conclusion_str = "{" + ", ".join([str(c) for c in conclusion]) + "}"
+        #     else:
+        #         conclusion_str = "{" + str(conclusion) + "}"
+        # else:
+        func, func_call = get_rule_conclusion_as_source_code(self, conclusion_str, parent_indent=parent_indent)
+        conclusion_str = func_call.replace("return ", "").strip()
 
         statement = f"{indent}conclusions.update(make_set({conclusion_str}))\n"
         if self.alternative is None:

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.67}/src/ripple_down_rules/utils.py

@@ -10,6 +10,7 @@ import re
 from collections import UserDict
 from copy import deepcopy
 from dataclasses import is_dataclass, fields
+from enum import Enum
 from types import NoneType
 
 import matplotlib
@@ -34,6 +35,58 @@ import ast
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def encapsulate_user_input(user_input: str, func_signature: str) -> str:
+    """
+    Encapsulate the user input string with a function definition.
+
+    :param user_input: The user input string.
+    :param func_signature: The function signature to use for encapsulation.
+    :return: The encapsulated user input string.
+    """
+    if func_signature not in user_input:
+        new_user_input = func_signature + "\n    "
+        if "return " not in user_input:
+            if '\n' not in user_input:
+                new_user_input += f"return {user_input}"
+            else:
+                raise ValueError("User input must contain a return statement or be a single line.")
+        else:
+            for cl in user_input.split('\n'):
+                sub_code_lines = cl.split('\n')
+                new_user_input += '\n    '.join(sub_code_lines) + '\n    '
+    else:
+        new_user_input = user_input
+    return new_user_input
+
+
+def build_user_input_from_conclusion(conclusion: Any) -> str:
+    """
+    Build a user input string from the conclusion.
+
+    :param conclusion: The conclusion to use for the callable expression.
+    :return: The user input string.
+    """
+
+    # set user_input to the string representation of the conclusion
+    if isinstance(conclusion, set):
+        user_input = '{' + f"{', '.join([conclusion_to_str(t) for t in conclusion])}" + '}'
+    elif isinstance(conclusion, list):
+        user_input = '[' + f"{', '.join([conclusion_to_str(t) for t in conclusion])}" + ']'
+    elif isinstance(conclusion, tuple):
+        user_input = '(' + f"{', '.join([conclusion_to_str(t) for t in conclusion])}" + ')'
+    else:
+        user_input = conclusion_to_str(conclusion)
+
+    return user_input
+
+
+def conclusion_to_str(conclusion_: Any) -> str:
+    if isinstance(conclusion_, Enum):
+        return type(conclusion_).__name__ + '.' + conclusion_.name
+    else:
+        return str(conclusion_)
+
+
 def update_case(case_query: CaseQuery, conclusions: Dict[str, Any]):
     """
     Update the case with the conclusions.

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.67}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.66
+Version: 0.1.67
 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.1.66 → ripple_down_rules-0.1.67}/test/test_relational_rdr.py

@@ -54,6 +54,7 @@ class RelationalRDRTestCase(TestCase):
     part_d: Part
     part_e: Part
     part_f: Part
+    target: List[PhysicalObject]
 
     @classmethod
     def setUpClass(cls):
@@ -71,8 +72,8 @@ class RelationalRDRTestCase(TestCase):
         cls.part_d.contained_objects = [cls.part_e]
         cls.part_e.contained_objects = [cls.part_f]
         cls.robot: Robot = robot
-        cls.case_query = CaseQuery(robot, "contained_objects", (PhysicalObject,), False,
-                                   _target=[cls.part_b, cls.part_c, cls.part_d, cls.part_e])
+        cls.case_query = CaseQuery(robot, "contained_objects", (PhysicalObject,), False)
+        cls.target = [cls.part_b, cls.part_c, cls.part_d, cls.part_e]
 
     def test_classify_scrdr(self):
         use_loaded_answers = True
@@ -86,7 +87,7 @@ class RelationalRDRTestCase(TestCase):
         cat = scrdr.fit_case(CaseQuery(self.robot, "contained_objects", (PhysicalObject,), False), expert=expert)
         render_tree(scrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + "/relational_scrdr_classify")
-        assert cat == self.case_query.target(self.case_query.case)
+        assert cat == self.target
 
         if save_answers:
             cwd = os.getcwd()
@@ -105,4 +106,4 @@ class RelationalRDRTestCase(TestCase):
         conclusion = CallableExpression(user_input, list)
         print(conclusion)
         print(conclusion(self.robot))
-        assert conclusion(self.robot) == self.case_query.target(self.case_query.case)
+        assert conclusion(self.robot) == self.target

{ripple_down_rules-0.1.66 → ripple_down_rules-0.1.67}/test/test_relational_rdr_alchemy.py

@@ -108,6 +108,7 @@ class RelationalRDRTestCase(TestCase):
     part_f: PhysicalObject
     rob_has_parts: List[HasPart]
     containments: List[ContainsObject]
+    target: List[PhysicalObject]
 
     @classmethod
     def setUpClass(cls):
@@ -129,8 +130,8 @@ class RelationalRDRTestCase(TestCase):
         cls.containments.append(ContainsObject(left=cls.part_d, right=cls.part_e))
         cls.containments.append(ContainsObject(left=cls.part_e, right=cls.part_f))
         cls.robot: PhysicalObject = robot
-        cls.case_query = CaseQuery(robot, robot.contained_objects, (PhysicalObject,), False,
-                                   _target=[cls.part_b, cls.part_c, cls.part_d, cls.part_e])
+        cls.case_query = CaseQuery(robot, robot.contained_objects, (PhysicalObject,), False)
+        cls.target = [cls.part_b, cls.part_c, cls.part_d, cls.part_e]
 
     def test_setup(self):
         assert self.robot.parts == [self.part_a, self.part_b, self.part_c, self.part_d]
@@ -153,7 +154,7 @@ class RelationalRDRTestCase(TestCase):
         cat = scrdr.fit_case(CaseQuery(self.robot, "contained_objects", (PhysicalObject,), False), expert=expert)
         render_tree(scrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + "/relational_scrdr_classify")
-        assert cat == self.case_query.target(self.case_query.case)
+        assert cat == self.target
 
         if save_answers:
             cwd = os.getcwd()
@@ -172,4 +173,4 @@ class RelationalRDRTestCase(TestCase):
         conclusion = CallableExpression(user_input, list)
         print(conclusion)
         print(conclusion(self.robot))
-        assert conclusion(self.robot) == self.case_query.target(self.case_query.case)
+        assert conclusion(self.robot) == self.target