ripple-down-rules 0.2.0__tar.gz → 0.2.2__tar.gz

{ripple_down_rules-0.2.0 → ripple_down_rules-0.2.2}/PKG-INFO

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

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.2.0"
+version = "0.2.2"
 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.2.0 → ripple_down_rules-0.2.2}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -9,7 +9,8 @@ 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, \
-    build_user_input_from_conclusion, encapsulate_user_input, extract_function_source
+    build_user_input_from_conclusion, encapsulate_user_input, extract_function_source, are_results_subclass_of_types, \
+    make_list
 
 
 class VariableVisitor(ast.NodeVisitor):
@@ -133,15 +134,16 @@ class CallableExpression(SubclassJSONSerializer):
                 if output is None:
                     output = scope['_get_value'](case)
                 if self.conclusion_type is not None:
-                    if is_iterable(output) and not isinstance(output, self.conclusion_type):
-                        assert isinstance(list(output)[0], self.conclusion_type), (f"Expected output type {self.conclusion_type},"
-                                                                                 f" got {type(output)}")
-                    else:
-                        assert isinstance(output, self.conclusion_type), (f"Expected output type {self.conclusion_type},"
-                                                                          f" got {type(output)}")
+                    output_types = {type(o) for o in make_list(output)}
+                    output_types.add(type(output))
+                    if not are_results_subclass_of_types(output_types, self.conclusion_type):
+                        raise ValueError(f"Not all result types {output_types} are subclasses of expected types"
+                                         f" {self.conclusion_type}")
                 return output
-            else:
+            elif self.conclusion is not None:
                 return self.conclusion
+            else:
+                raise ValueError("Either user_input or conclusion must be provided.")
         except Exception as e:
             raise ValueError(f"Error during evaluation: {e}")
 

{ripple_down_rules-0.2.0 → ripple_down_rules-0.2.2}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -83,6 +83,13 @@ class CaseQuery:
             raise ValueError("The case must be a Case or SQLTable object.")
         self._case = value
 
+    @property
+    def core_attribute_type(self) -> Tuple[Type]:
+        """
+        :return: The core type of the attribute.
+        """
+        return (t for t in self.attribute_type if t not in (set, list))
+
     @property
     def attribute_type(self) -> Tuple[Type]:
         """

{ripple_down_rules-0.2.0 → ripple_down_rules-0.2.2}/src/ripple_down_rules/prompt.py

@@ -10,14 +10,15 @@ from textwrap import indent, dedent
 from IPython.core.magic import register_line_magic, line_magic, Magics, magics_class
 from IPython.terminal.embed import InteractiveShellEmbed
 from traitlets.config import Config
-from typing_extensions import List, Optional, Tuple, Dict, Type, Union
+from typing_extensions import List, Optional, Tuple, Dict, Type, Union, Any
 
 from .datastructures.enums import PromptFor
 from .datastructures.case import Case
 from .datastructures.callable_expression import CallableExpression, parse_string_to_expression
 from .datastructures.dataclasses import CaseQuery
 from .utils import extract_dependencies, contains_return_statement, make_set, get_imports_from_scope, make_list, \
-    get_import_from_type, get_imports_from_types, is_iterable, extract_function_source, encapsulate_user_input
+    get_import_from_type, get_imports_from_types, is_iterable, extract_function_source, encapsulate_user_input, \
+    are_results_subclass_of_types
 
 
 @magics_class
@@ -259,7 +260,6 @@ class IPythonShell:
             if len(self.all_code_lines) == 1 and self.all_code_lines[0].strip() == '':
                 self.user_input = None
             else:
-                import pdb; pdb.set_trace()
                 self.user_input = '\n'.join(self.all_code_lines)
                 self.user_input = encapsulate_user_input(self.user_input, self.shell.my_magics.function_signature,
                                                          self.func_doc)
@@ -278,6 +278,7 @@ def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, pro
     :return: A callable expression that takes a case and executes user expression on it.
     """
     prev_user_input: Optional[str] = None
+    callable_expression: Optional[CallableExpression] = None
     while True:
         user_input, expression_tree = prompt_user_about_case(case_query, prompt_for, prompt_str,
                                                              code_to_modify=prev_user_input)
@@ -294,9 +295,8 @@ def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, pro
                                                  scope=case_query.scope)
         try:
             result = callable_expression(case_query.case)
-            result = make_list(result)
-            if len(result) == 0:
-                print(f"The given expression gave an empty result for case {case_query.name}, please modify")
+            if len(make_list(result)) == 0:
+                print(f"The given expression gave an empty result for case {case_query.name}. Please modify!")
                 continue
             break
         except Exception as e:

{ripple_down_rules-0.2.0 → ripple_down_rules-0.2.2}/src/ripple_down_rules/utils.py

@@ -36,6 +36,20 @@ import ast
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def are_results_subclass_of_types(result_types: List[Any], types_: List[Type]) -> bool:
+    """
+    Check if all results are subclasses of the given types.
+
+    :param result_types: The list of result types to check.
+    :param types_: The list of types to check against.
+    :return: True if all results are subclasses of the given types, False otherwise.
+    """
+    for rt in result_types:
+        if not any(issubclass(rt, t) for t in types_):
+            return False
+    return True
+
+
 def get_imports_from_types(types: List[Type]) -> List[str]:
     """
     Get the import statements for a list of types.

{ripple_down_rules-0.2.0 → ripple_down_rules-0.2.2}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.2.0
+Version: 0.2.2
 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.2.0 → ripple_down_rules-0.2.2}/test/test_rdr_alchemy.py

@@ -128,7 +128,7 @@ class TestAlchemyRDR(TestCase):
         case_queries = []
         for case, targets in zip(self.all_cases[:n], habitat_targets):
             for attr, target in targets.items():
-                case_queries.append(CaseQuery(case, attr, (Species,) if attr == 'species' else (Habitat,),
+                case_queries.append(CaseQuery(case, attr, (Species,) if attr == 'species' else (HabitatTable,),
                                               True if attr == 'species' else False, _target=target))
         grdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
         for rule in grdr.start_rules:

{ripple_down_rules-0.2.0 → ripple_down_rules-0.2.2}/test/test_relational_rdr.py

@@ -5,6 +5,7 @@ from unittest import TestCase
 
 from typing_extensions import List, Optional, Any
 
+from ripple_down_rules.datastructures.case import CaseAttribute
 from ripple_down_rules.datastructures.dataclasses import CaseQuery, CallableExpression
 from ripple_down_rules.experts import Human
 from ripple_down_rules.rdr import SingleClassRDR
@@ -103,7 +104,7 @@ class RelationalRDRTestCase(TestCase):
 
     def test_parse_relational_conclusions(self):
         user_input = "case.parts.contained_objects"
-        conclusion = CallableExpression(user_input, list)
+        conclusion = CallableExpression(user_input, (CaseAttribute, PhysicalObject,))
         print(conclusion)
         print(conclusion(self.robot))
         assert conclusion(self.robot) == self.target

{ripple_down_rules-0.2.0 → ripple_down_rules-0.2.2}/test/test_relational_rdr_alchemy.py

@@ -7,6 +7,7 @@ from sqlalchemy import ForeignKey
 from sqlalchemy.orm import MappedAsDataclass, DeclarativeBase, declared_attr, Mapped, mapped_column, relationship
 from typing_extensions import List, Any, Set
 
+from ripple_down_rules.datastructures.case import CaseAttribute
 from ripple_down_rules.datastructures.dataclasses import CaseQuery
 from ripple_down_rules.datastructures.callable_expression import CallableExpression
 from ripple_down_rules.experts import Human
@@ -170,7 +171,7 @@ class RelationalRDRTestCase(TestCase):
 
     def test_parse_relational_conclusions(self):
         user_input = "case.parts.contained_objects"
-        conclusion = CallableExpression(user_input, list)
+        conclusion = CallableExpression(user_input, (CaseAttribute, PhysicalObject,))
         print(conclusion)
         print(conclusion(self.robot))
         assert conclusion(self.robot) == self.target