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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.65
+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.65 → 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.65"
+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.65 → 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.65 → 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.65 → 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.65 → 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.65 → ripple_down_rules-0.1.67}/src/ripple_down_rules/rdr.py

@@ -326,13 +326,10 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         :return: The type of the conclusion of the RDR classifier.
         """
-        if isinstance(self.start_rule.conclusion, CallableExpression):
-            return self.start_rule.conclusion.conclusion_type
-        else:
-            conclusion = self.start_rule.conclusion
-            if isinstance(conclusion, set):
-                return type(list(conclusion)[0]), set
-            return (type(conclusion),)
+        all_types = []
+        for rule in [self.start_rule] + list(self.start_rule.descendants):
+            all_types.extend(list(rule.conclusion.conclusion_type))
+        return tuple(set(all_types))
 
     @property
     def attribute_name(self) -> str:
@@ -419,7 +416,8 @@ class SingleClassRDR(RDRWithCodeWriter):
                 self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ",
                                                         defs_file=defs_file)
 
-            file.write(rule.write_conclusion_as_source_code(parent_indent))
+            conclusion_call = rule.write_conclusion_as_source_code(parent_indent, defs_file)
+            file.write(conclusion_call)
 
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent, defs_file=defs_file)
@@ -532,18 +530,20 @@ class MultiClassRDR(RDRWithCodeWriter):
                                                         defs_file=defs_file)
                 conclusion_indent = parent_indent + " " * 4
                 file.write(f"{conclusion_indent}else:\n")
-            file.write(rule.write_conclusion_as_source_code(conclusion_indent))
+
+            conclusion_call = rule.write_conclusion_as_source_code(conclusion_indent, defs_file)
+            file.write(conclusion_call)
 
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent, defs_file=defs_file)
 
     @property
     def conclusion_type_hint(self) -> str:
-        return f"Set[{self.conclusion_type[0].__name__}]"
+        return f"Set[Union[{', '.join([ct.__name__ for ct in self.conclusion_type if ct not in [list, set]])}]]"
 
     def _get_imports(self) -> str:
         imports = super()._get_imports()
-        imports += "from typing_extensions import Set\n"
+        imports += "from typing_extensions import Set, Union\n"
         imports += "from ripple_down_rules.utils import make_set\n"
         return imports
 
@@ -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.
@@ -871,7 +871,7 @@ class GeneralRDR(RippleDownRules):
 
     @property
     def conclusion_type_hint(self) -> str:
-        return f"List[Union[{', '.join([rdr.conclusion_type_hint for rdr in self.start_rules_dict.values()])}]]"
+        return f"Dict[str, Any]"
 
     def _get_imports(self, file_path: str) -> str:
         """
@@ -882,7 +882,7 @@ class GeneralRDR(RippleDownRules):
         """
         imports = ""
         # add type hints
-        imports += f"from typing_extensions import List, Union, Set\n"
+        imports += f"from typing_extensions import Dict, Any, Union, Set\n"
         # import rdr type
         imports += f"from ripple_down_rules.rdr import GeneralRDR\n"
         # add case type

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

@@ -5,7 +5,7 @@ from abc import ABC, abstractmethod
 from enum import Enum
 
 from anytree import NodeMixin
-from typing_extensions import List, Optional, Self, Union, Dict, Any
+from typing_extensions import List, Optional, Self, Union, Dict, Any, Tuple
 
 from .datastructures.callable_expression import CallableExpression
 from .datastructures.case import Case
@@ -78,24 +78,26 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         """
         pass
 
-    def write_conclusion_as_source_code(self, parent_indent: str = "") -> str:
+    def write_conclusion_as_source_code(self, parent_indent: str = "", defs_file: Optional[str] = None) -> str:
         """
         Get the source code representation of the conclusion of the rule.
 
         :param parent_indent: The indentation of the parent rule.
+        :param defs_file: The file to write the conclusion to if it is a definition.
+        :return: The source code representation of the conclusion of the rule.
         """
-        conclusion = self.conclusion
-        if isinstance(conclusion, CallableExpression):
-            if self.conclusion.user_input is not None:
-                conclusion = self.conclusion.user_input
-            else:
-                conclusion = self.conclusion.conclusion
-        if isinstance(conclusion, Enum):
-            conclusion = str(conclusion)
-        return self._conclusion_source_code(conclusion, parent_indent=parent_indent)
+        if self.conclusion.user_input is not None:
+            conclusion = self.conclusion.user_input
+        else:
+            conclusion = self.conclusion.conclusion
+        conclusion_func, conclusion_func_call = self._conclusion_source_code(conclusion, parent_indent=parent_indent)
+        if conclusion_func is not None:
+            with open(defs_file, 'a') as f:
+                f.write(conclusion_func + "\n\n")
+        return conclusion_func_call
 
     @abstractmethod
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
+    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[Optional[str], str]:
         pass
 
     def write_condition_as_source_code(self, parent_indent: str = "", defs_file: Optional[str] = None) -> str:
@@ -118,7 +120,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             conditions_lines[0] = re.sub(r"def (\w+)", new_function_name, conditions_lines[0])
             def_code = "\n".join(conditions_lines)
             with open(defs_file, 'a') as f:
-                f.write(def_code + "\n")
+                f.write(def_code + "\n\n")
             return f"\n{parent_indent}{if_clause} {new_function_name.replace('def ', '')}(case):\n"
 
     @abstractmethod
@@ -266,13 +268,13 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
         loaded_rule.alternative = SingleClassRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
+    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 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"
@@ -317,8 +319,8 @@ class MultiClassStopRule(Rule, HasAlternativeRule):
         loaded_rule.alternative = MultiClassStopRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
-        return f"{parent_indent}{' ' * 4}pass\n"
+    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[None, str]:
+        return None, f"{parent_indent}{' ' * 4}pass\n"
 
     def _if_statement_source_code_clause(self) -> str:
         return "elif" if self.weight == RDREdge.Alternative.value else "if"
@@ -362,25 +364,23 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
         loaded_rule.alternative = MultiClassTopRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
+    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[str, str]:
         conclusion_str = str(conclusion)
         indent = parent_indent + " " * 4
-        statement = ""
-        if '\n' not in conclusion_str:
-            if is_iterable(conclusion):
-                conclusion_str = "{" + ", ".join([str(c) for c in conclusion]) + "}"
-            else:
-                conclusion_str = "{" + str(conclusion) + "}"
-        else:
-            conclusion_str = get_rule_conclusion_as_source_code(self, conclusion_str, parent_indent=parent_indent)
-            lines = conclusion_str.split("\n")
-            conclusion_str = lines[-2].replace("return ", "").strip()
-            statement += "\n".join(lines[:-2]) + "\n"
-
-        statement += f"{indent}conclusions.update(make_set({conclusion_str}))\n"
+        # 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:
             statement += f"{parent_indent}return conclusions\n"
-        return statement
+        return func, statement
 
     def _if_statement_source_code_clause(self) -> str:
         return "if"

{ripple_down_rules-0.1.65 → 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.
@@ -119,14 +172,14 @@ def calculate_precision_and_recall(pred_cat: Dict[str, Any], target: Dict[str, A
     return precision, recall
 
 
-def get_rule_conclusion_as_source_code(rule: Rule, conclusion: str, parent_indent: str = "") -> str:
+def get_rule_conclusion_as_source_code(rule: Rule, conclusion: str, parent_indent: str = "") -> Tuple[str, str]:
     """
     Convert the conclusion of a rule to source code.
 
     :param rule: The rule to get the conclusion from.
     :param conclusion: The conclusion to convert to source code.
     :param parent_indent: The indentation to use for the source code.
-    :return: The source code of the conclusion.
+    :return: The source code of the conclusion as a tuple of strings, one for the function and one for the call.
     """
     indent = f"{parent_indent}{' ' * 4}"
     if "def " in conclusion:
@@ -135,9 +188,8 @@ def get_rule_conclusion_as_source_code(rule: Rule, conclusion: str, parent_inden
         # use regex to replace the function name
         new_function_name = f"def conclusion_{id(rule)}"
         conclusion_lines[0] = re.sub(r"def (\w+)", new_function_name, conclusion_lines[0])
-        conclusion_lines = [f"{indent}{line}" for line in conclusion_lines]
-        conclusion_lines.append(f"{indent}return {new_function_name.replace('def ', '')}(case)\n")
-        return "\n".join(conclusion_lines)
+        func_call = f"{indent}return {new_function_name.replace('def ', '')}(case)\n"
+        return "\n".join(conclusion_lines).strip(' '), func_call
     else:
         raise ValueError(f"Conclusion is format is not valid, it should be a one line string or "
                          f"contain a function definition. Instead got:\n{conclusion}\n")

{ripple_down_rules-0.1.65 → 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.65
+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.65 → 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.65 → 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