ripple-down-rules 0.0.4__tar.gz → 0.0.6__tar.gz

{ripple_down_rules-0.0.4 → ripple_down_rules-0.0.6}/PKG-INFO

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

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.0.4"
+version = "0.0.6"
 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.0.4 → ripple_down_rules-0.0.6}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
-from copy import copy, deepcopy
 from dataclasses import dataclass
 
 from sqlalchemy.orm import DeclarativeBase as SQLTable
-from typing_extensions import Any, Optional, Type, Union
+from typing_extensions import Any, Optional, Type
 
 from .table import create_row, Case
-from ..utils import get_attribute_name, copy_orm_instance_with_relationships, copy_case
+from ..utils import get_attribute_name, copy_case
 
 
 @dataclass

{ripple_down_rules-0.0.4 → ripple_down_rules-0.0.6}/src/ripple_down_rules/datastructures/enums.py

@@ -17,7 +17,7 @@ class Category(str, Enum):
 
     @property
     def as_dict(self):
-        return {self.__class__.__name__.lower(): self.value}
+        return {self.__class__.__name__.lower(): self}
 
 
 class Stop(Category):

{ripple_down_rules-0.0.4 → ripple_down_rules-0.0.6}/src/ripple_down_rules/datastructures/table.py

@@ -4,7 +4,7 @@ import os
 import time
 from abc import ABC
 from collections import UserDict
-from copy import deepcopy
+from copy import deepcopy, copy
 from dataclasses import dataclass
 from enum import Enum
 
@@ -78,7 +78,7 @@ class SubClassFactory:
         parent_class_alias = cls.__name__ + "_"
         imports = f"from {cls.__module__} import {cls.__name__} as {parent_class_alias}\n"
         class_code = f"class {name}({parent_class_alias}):\n"
-        class_attributes = deepcopy(class_attributes) if class_attributes else {}
+        class_attributes = copy(class_attributes) if class_attributes else {}
         class_attributes.update({"_value_range": range_})
         for key, value in class_attributes.items():
             if value is not None:
@@ -219,10 +219,10 @@ class Row(UserDict, SubClassFactory, SubclassJSONSerializer):
                 value.update(make_set(self[name]))
                 super().__setitem__(name, value)
             else:
-                super().__setitem__(name, make_set(self[name]))
+                super().__setitem__(name, make_set([self[name], value]))
         else:
-            setattr(self, name, value)
             super().__setitem__(name, value)
+        setattr(self, name, self[name])
 
     def __contains__(self, item):
         if isinstance(item, (type, Enum)):
@@ -428,9 +428,10 @@ def create_row(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
         row = create_or_update_row_from_attribute(attr_value, attr, obj, attr, recursion_idx,
                                                   max_recursion_idx, parent_is_iterable, row)
         attributes_type_hints[attr] = get_value_type_from_type_hint(attr, obj)
-    row_cls = Row.create(obj_name or obj.__class__.__name__, make_set(type(obj)), row, default_values=False,
-                         attributes_type_hints=attributes_type_hints)
-    row = row_cls(id_=id(obj), **row)
+    if recursion_idx == 0:
+        row_cls = Row.create(obj_name or obj.__class__.__name__, make_set(type(obj)), row, default_values=False,
+                             attributes_type_hints=attributes_type_hints)
+        row = row_cls(id_=id(obj), **row)
     return row
 
 
@@ -462,9 +463,6 @@ def create_or_update_row_from_attribute(attr_value: Any, name: str, obj: Any, ob
         row[obj_name] = column
     else:
         row[obj_name] = make_set(attr_value) if parent_is_iterable else attr_value
-    if row.__class__.__name__ == "Row":
-        row_cls = Row.create(obj_name or obj.__class__.__name__, make_set(type(obj)), row, default_values=False)
-        row = row_cls(id_=id(obj), **row)
     return row
 
 
@@ -490,14 +488,11 @@ def create_column_and_row_from_iterable_attribute(attr_value: Any, name: str, ob
         raise ValueError(f"Could not determine the range of {name} in {obj}.")
     attr_row = Row(id_=id(attr_value))
     column = Column.create(name, range_).from_obj(values, row_obj=obj)
-    attributes_type_hints = {}
     for idx, val in enumerate(values):
         sub_attr_row = create_row(val, recursion_idx=recursion_idx,
                                   max_recursion_idx=max_recursion_idx,
                                   obj_name=obj_name, parent_is_iterable=True)
         attr_row.update(sub_attr_row)
-    # attr_row_cls = Row.create(name or list(range_)[0].__name__, range_, attr_row, default_values=False)
-    # attr_row = attr_row_cls(id_=id(attr_value), **attr_row)
     for sub_attr, val in attr_row.items():
         setattr(column, sub_attr, val)
     return column, attr_row

{ripple_down_rules-0.0.4 → ripple_down_rules-0.0.6}/src/ripple_down_rules/experts.py

@@ -9,7 +9,7 @@ from typing_extensions import Optional, Dict, TYPE_CHECKING, List, Tuple, Type,
 from .datastructures import (Case, PromptFor, CallableExpression, Column, CaseQuery)
 from .datastructures.table import show_current_and_corner_cases
 from .prompt import prompt_user_for_expression, prompt_user_about_case
-from .utils import get_all_subclasses
+from .utils import get_all_subclasses, is_iterable
 
 if TYPE_CHECKING:
     from .rdr import Rule
@@ -97,14 +97,23 @@ class Human(Expert):
         self.use_loaded_answers = use_loaded_answers
         self.session = session
 
-    def save_answers(self, path: str):
+    def save_answers(self, path: str, append: bool = False):
         """
         Save the expert answers to a file.
 
         :param path: The path to save the answers to.
+        :param append: A flag to indicate if the answers should be appended to the file or not.
         """
-        with open(path + '.json', "w") as f:
-            json.dump(self.all_expert_answers, f)
+        if append:
+            # read the file and append the new answers
+            with open(path + '.json', "r") as f:
+                all_answers = json.load(f)
+                all_answers.extend(self.all_expert_answers)
+            with open(path + '.json', "w") as f:
+                json.dump(all_answers, f)
+        else:
+            with open(path + '.json', "w") as f:
+                json.dump(self.all_expert_answers, f)
 
     def load_answers(self, path: str):
         """
@@ -116,7 +125,7 @@ class Human(Expert):
             self.all_expert_answers = json.load(f)
 
     def ask_for_conditions(self, case: Case,
-                           targets: Union[List[Column], List[Column]],
+                           targets: Union[List[Column], List[SQLColumn]],
                            last_evaluated_rule: Optional[Rule] = None) \
             -> CallableExpression:
         if not self.use_loaded_answers:

{ripple_down_rules-0.0.4 → ripple_down_rules-0.0.6}/src/ripple_down_rules/rdr.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from copy import copy
+from copy import copy, deepcopy
 
 from matplotlib import pyplot as plt
 from ordered_set import OrderedSet
 from sqlalchemy.orm import DeclarativeBase as SQLTable, Session
-from typing_extensions import List, Optional, Dict, Type, Union, Any, Self
+from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tuple
 
 from .datastructures import Case, MCRDRMode, CallableExpression, Column, CaseQuery
 from .experts import Expert, Human
 from .rules import Rule, SingleClassRule, MultiClassTopRule
 from .utils import draw_tree, make_set, get_attribute_by_type, copy_case, \
-    get_hint_for_attribute, SubclassJSONSerializer
+    get_hint_for_attribute, SubclassJSONSerializer, is_iterable, make_list
 
 
 class RippleDownRules(ABC):
@@ -51,7 +51,7 @@ class RippleDownRules(ABC):
         pass
 
     @abstractmethod
-    def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs)\
+    def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
             -> Union[Column, CallableExpression]:
         """
         Fit the RDR on a case, and ask the expert for refinements or alternatives if the classification is incorrect by
@@ -86,8 +86,6 @@ class RippleDownRules(ABC):
         num_rules: int = 0
         while not stop_iterating:
             all_pred = 0
-            all_recall = []
-            all_precision = []
             if not targets:
                 targets = [None] * len(cases)
             for case_query in case_queries:
@@ -97,14 +95,7 @@ class RippleDownRules(ABC):
                     conclusions = self.classify(case) if self.start_rule and self.start_rule.conditions else []
                     target = expert.ask_for_conclusion(case_query, conclusions)
                 pred_cat = self.fit_case(case_query, expert=expert, **kwargs_for_fit_case)
-                pred_cat = pred_cat if isinstance(pred_cat, list) else [pred_cat]
-                target = target if isinstance(target, list) else [target]
-                recall = [not yi or (yi in pred_cat) for yi in target]
-                y_type = [type(yi) for yi in target]
-                precision = [(pred in target) or (type(pred) not in y_type) for pred in pred_cat]
-                match = all(recall) and all(precision)
-                all_recall.extend(recall)
-                all_precision.extend(precision)
+                match = self.is_matching(pred_cat, target)
                 if not match:
                     print(f"Predicted: {pred_cat} but expected: {target}")
                 all_pred += int(match)
@@ -112,21 +103,45 @@ class RippleDownRules(ABC):
                     num_rules = self.start_rule.size
                     self.update_figures()
             i += 1
-            all_pred = [1 if p == t else 0
-                        for case, target in zip(cases, targets) for p, t in zip(self.classify(case), target)]
-            all_predicted = targets and sum(all_pred) == len(targets)
+            all_predictions = [1 if self.is_matching(self.classify(case), target) else 0
+                               for case, target in zip(cases, targets)]
+            all_pred = sum(all_predictions)
+            print(f"Accuracy: {all_pred}/{len(targets)}")
+            all_predicted = targets and all_pred == len(targets)
             num_iter_reached = n_iter and i >= n_iter
             stop_iterating = all_predicted or num_iter_reached
             if stop_iterating:
                 break
-            print(f"Recall: {sum(all_recall) / len(all_recall)}")
-            print(f"Precision: {sum(all_precision) / len(all_precision)}")
-            print(f"Accuracy: {all_pred}/{len(targets)}")
         print(f"Finished training in {i} iterations")
         if animate_tree:
             plt.ioff()
             plt.show()
 
+    @staticmethod
+    def calculate_precision_and_recall(pred_cat: List[Column], target: List[Column]) -> Tuple[List[bool], List[bool]]:
+        """
+        :param pred_cat: The predicted category.
+        :param target: The target category.
+        :return: The precision and recall of the classifier.
+        """
+        pred_cat = pred_cat if is_iterable(pred_cat) else [pred_cat]
+        target = target if is_iterable(target) else [target]
+        recall = [not yi or (yi in pred_cat) for yi in target]
+        target_types = [type(yi) for yi in target]
+        if len(pred_cat) > 1:
+            print(pred_cat)
+        precision = [(pred in target) or (type(pred) not in target_types) for pred in pred_cat]
+        return precision, recall
+
+    def is_matching(self, pred_cat: List[Column], target: List[Column]) -> bool:
+        """
+        :param pred_cat: The predicted category.
+        :param target: The target category.
+        :return: Whether the classifier is matching or not.
+        """
+        precision, recall = self.calculate_precision_and_recall(pred_cat, target)
+        return all(recall) and all(precision)
+
     def update_figures(self):
         """
         Update the figures of the classifier.
@@ -345,7 +360,7 @@ class MultiClassRDR(RippleDownRules):
                         self.add_conclusion(evaluated_rule)
 
                 if not next_rule:
-                    if target not in self.conclusions:
+                    if not make_set(target).intersection(make_set(self.conclusions)):
                         # Nothing fired and there is a target that should have been in the conclusions
                         self.add_rule_for_case(case, target, expert)
                         # Have to check all rules again to make sure only this new rule fires
@@ -496,15 +511,16 @@ class MultiClassRDR(RippleDownRules):
         """
         conclusion_types = [type(c) for c in self.conclusions]
         if type(evaluated_rule.conclusion) not in conclusion_types:
-            self.conclusions.append(evaluated_rule.conclusion)
+            self.conclusions.extend(make_list(evaluated_rule.conclusion))
         else:
             same_type_conclusions = [c for c in self.conclusions if type(c) == type(evaluated_rule.conclusion)]
             combined_conclusion = evaluated_rule.conclusion if isinstance(evaluated_rule.conclusion, set) \
                 else {evaluated_rule.conclusion}
+            combined_conclusion = copy(combined_conclusion)
             for c in same_type_conclusions:
                 combined_conclusion.update(c if isinstance(c, set) else make_set(c))
                 self.conclusions.remove(c)
-            self.conclusions.extend(combined_conclusion)
+            self.conclusions.extend(make_list(combined_conclusion))
 
     def add_top_rule(self, conditions: CallableExpression, conclusion: Any, corner_case: Union[Case, SQLTable]):
         """
@@ -573,16 +589,16 @@ class GeneralRDR(RippleDownRules):
                     continue
                 pred_atts = rdr.classify(case_cp)
                 if pred_atts:
-                    pred_atts = pred_atts if isinstance(pred_atts, list) else [pred_atts]
+                    pred_atts = make_list(pred_atts)
                     pred_atts = [p for p in pred_atts if p not in conclusions]
                     added_attributes = True
                     conclusions.extend(pred_atts)
-                    self.update_case_with_same_type_conclusions(case_cp, pred_atts)
+                    GeneralRDR.update_case(case_cp, pred_atts)
             if not added_attributes:
                 break
         return conclusions
 
-    def fit_case(self, case_queries: List[CaseQuery], expert: Optional[Expert] = None, **kwargs)\
+    def fit_case(self, case_queries: List[CaseQuery], expert: Optional[Expert] = None, **kwargs) \
             -> List[Union[Column, CallableExpression]]:
         """
         Fit the GRDR on a case, if the target is a new type of category, a new RDR is created for it,
@@ -610,21 +626,27 @@ class GeneralRDR(RippleDownRules):
             if not target:
                 target = expert.ask_for_conclusion(case_query)
             case_query_cp = CaseQuery(case_cp, attribute_name=case_query.attribute_name, target=target)
-            if type(target) not in self.start_rules_dict:
+            if is_iterable(target) and not isinstance(target, Column):
+                target_type = type(make_list(target)[0])
+                assert all([type(t) is target_type for t in target]), ("All targets of a case query must be of the same"
+                                                                       " type")
+            else:
+                target_type = type(target)
+            if target_type not in self.start_rules_dict:
                 conclusions = self.classify(case)
-                self.update_case_with_same_type_conclusions(case_cp, conclusions)
+                self.update_case(case_cp, conclusions)
                 new_rdr = self.initialize_new_rdr_for_attribute(target, case_cp)
                 new_conclusions = new_rdr.fit_case(case_query_cp, expert, **kwargs)
-                self.start_rules_dict[type(target)] = new_rdr
-                self.update_case_with_same_type_conclusions(case_cp, new_conclusions, type(target))
-            elif not self.case_has_conclusion(case_cp, type(target)):
+                self.start_rules_dict[target_type] = new_rdr
+                self.update_case(case_cp, new_conclusions, target_type)
+            elif not self.case_has_conclusion(case_cp, target_type):
                 for rdr_type, rdr in self.start_rules_dict.items():
-                    if type(target) is not rdr_type:
+                    if target_type is not rdr_type:
                         conclusions = rdr.classify(case_cp)
                     else:
-                        conclusions = self.start_rules_dict[type(target)].fit_case(case_query_cp,
+                        conclusions = self.start_rules_dict[target_type].fit_case(case_query_cp,
                                                                                    expert, **kwargs)
-                    self.update_case_with_same_type_conclusions(case_cp, conclusions, rdr_type)
+                    self.update_case(case_cp, conclusions, rdr_type)
 
         return self.classify(case)
 
@@ -639,12 +661,14 @@ class GeneralRDR(RippleDownRules):
                 return MultiClassRDR()
             else:
                 return SingleClassRDR()
-        else:
+        elif isinstance(attribute, Column):
             return SingleClassRDR() if attribute.mutually_exclusive else MultiClassRDR()
+        else:
+            return MultiClassRDR() if is_iterable(attribute) else SingleClassRDR()
 
     @staticmethod
-    def update_case_with_same_type_conclusions(case: Union[Case, SQLTable],
-                                               conclusions: List[Any], attribute_type: Optional[Any] = None):
+    def update_case(case: Union[Case, SQLTable],
+                    conclusions: List[Any], attribute_type: Optional[Any] = None):
         """
         Update the case with the conclusions.
 
@@ -654,7 +678,7 @@ class GeneralRDR(RippleDownRules):
         """
         if not conclusions:
             return
-        conclusions = [conclusions] if not isinstance(conclusions, list) else conclusions
+        conclusions = [conclusions] if not isinstance(conclusions, list) else list(conclusions)
         if len(conclusions) == 0:
             return
         if isinstance(case, SQLTable):
@@ -663,7 +687,8 @@ class GeneralRDR(RippleDownRules):
             hint, origin, args = get_hint_for_attribute(attr_name, case)
             if isinstance(attribute, set) or origin == set:
                 attribute = set() if attribute is None else attribute
-                attribute.update(*[make_set(c) for c in conclusions])
+                for c in conclusions:
+                    attribute.update(make_set(c))
             elif isinstance(attribute, list) or origin == list:
                 attribute = [] if attribute is None else attribute
                 attribute.extend(conclusions)
@@ -672,7 +697,8 @@ class GeneralRDR(RippleDownRules):
             else:
                 raise ValueError(f"Cannot add multiple conclusions to attribute {attr_name}")
         else:
-            case.update(*[c.as_dict for c in make_set(conclusions)])
+            for c in make_set(conclusions):
+                case.update(c.as_dict)
 
     @property
     def names_of_all_types(self) -> List[str]:

{ripple_down_rules-0.0.4 → ripple_down_rules-0.0.6}/src/ripple_down_rules/utils.py

@@ -24,6 +24,24 @@ if TYPE_CHECKING:
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def make_list(value: Any) -> List:
+    """
+    Make a list from a value.
+
+    :param value: The value to make a list from.
+    """
+    return list(value) if is_iterable(value) else [value]
+
+
+def is_iterable(obj: Any) -> bool:
+    """
+    Check if an object is iterable.
+
+    :param obj: The object to check.
+    """
+    return hasattr(obj, "__iter__") and not isinstance(obj, (str, type))
+
+
 def get_type_from_string(type_path: str):
     """
     Get a type from a string describing its path using the format "module_path.ClassName".
@@ -350,20 +368,7 @@ def make_set(value: Any) -> Set:
 
     :param value: The value to make a set from.
     """
-    if hasattr(value, "__iter__") and not isinstance(value, (str, type)):
-        return set(value)
-    return {value}
-
-
-def make_list(value: Any) -> List:
-    """
-    Make a list from a value.
-
-    :param value: The value to make a list from.
-    """
-    if hasattr(value, "__iter__") and not isinstance(value, (str, type)):
-        return list(value)
-    return [value]
+    return set(value) if is_iterable(value) else {value}
 
 
 def make_value_or_raise_error(value: Any) -> Any:

{ripple_down_rules-0.0.4 → ripple_down_rules-0.0.6}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.4
+Version: 0.0.6
 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.0.4 → ripple_down_rules-0.0.6}/test/test_rdr.py

@@ -3,7 +3,7 @@ from unittest import TestCase, skip
 
 from typing_extensions import List
 
-from ripple_down_rules.datasets import HabitatCol as Habitat, SpeciesCol as Species
+from ripple_down_rules.datasets import Habitat, SpeciesCol as Species
 from ripple_down_rules.datasets import load_zoo_dataset
 from ripple_down_rules.datastructures import Case, MCRDRMode, \
     Row, Column, Category, CaseQuery
@@ -102,7 +102,7 @@ class TestRDR(TestCase):
             expert.load_answers(filename)
         mcrdr = MultiClassRDR()
         case_queries = [CaseQuery(case, target=target) for case, target in zip(self.all_cases, self.targets)]
-        mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
+        mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree, n_iter=1)
         render_tree(mcrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + f"/mcrdr_stop_only")
         cats = mcrdr.classify(self.all_cases[50])
@@ -117,13 +117,22 @@ class TestRDR(TestCase):
         use_loaded_answers = True
         draw_tree = False
         save_answers = False
+        append = False
         filename = self.expert_answers_dir + "/mcrdr_stop_plus_rule_expert_answers_fit"
         expert = Human(use_loaded_answers=use_loaded_answers)
         if use_loaded_answers:
             expert.load_answers(filename)
         mcrdr = MultiClassRDR(mode=MCRDRMode.StopPlusRule)
         case_queries = [CaseQuery(case, target=target) for case, target in zip(self.all_cases, self.targets)]
-        mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
+        try:
+            mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
+        # catch pop from empty list error
+        except IndexError as e:
+            if append:
+                expert.use_loaded_answers = False
+                mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
+            else:
+                raise e
         render_tree(mcrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + f"/mcrdr_stop_plus_rule")
         cats = mcrdr.classify(self.all_cases[50])
@@ -132,19 +141,28 @@ class TestRDR(TestCase):
         if save_answers:
             cwd = os.getcwd()
             file = os.path.join(cwd, filename)
-            expert.save_answers(file)
+            expert.save_answers(file, append=append)
 
     def test_fit_mcrdr_stop_plus_rule_combined(self):
         use_loaded_answers = True
         save_answers = False
         draw_tree = False
+        append = False
         filename = self.expert_answers_dir + "/mcrdr_stop_plus_rule_combined_expert_answers_fit"
         expert = Human(use_loaded_answers=use_loaded_answers)
         if use_loaded_answers:
             expert.load_answers(filename)
         mcrdr = MultiClassRDR(mode=MCRDRMode.StopPlusRuleCombined)
         case_queries = [CaseQuery(case, target=target) for case, target in zip(self.all_cases, self.targets)]
-        mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
+        try:
+            mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
+        # catch pop from empty list error
+        except IndexError as e:
+            if append:
+                expert.use_loaded_answers = False
+                mcrdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
+            else:
+                raise e
         render_tree(mcrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + f"/mcrdr_stop_plus_rule_combined")
         cats = mcrdr.classify(self.all_cases[50])
@@ -153,7 +171,7 @@ class TestRDR(TestCase):
         if save_answers:
             cwd = os.getcwd()
             file = os.path.join(cwd, filename)
-            expert.save_answers(file)
+            expert.save_answers(file, append=append)
 
     @skip("Extra conclusions loaded answers are not working with new prompt interface")
     def test_classify_mcrdr_with_extra_conclusions(self):
@@ -235,19 +253,19 @@ class TestRDR(TestCase):
         def get_habitat(x: Row, t: Category):
             all_habs = []
             if t == Species.mammal and x["aquatic"] == 0:
-                all_habs.append(Habitat.land)
+                all_habs.append({Habitat.land})
             elif t == Species.bird:
-                all_habs.append(Habitat.land)
+                all_habs.append({Habitat.land})
                 if x["airborne"] == 1:
-                    all_habs[-1].update(Habitat.air)
+                    all_habs[-1].update({Habitat.air})
                 if x["aquatic"] == 1:
-                    all_habs[-1].update(Habitat.water)
+                    all_habs[-1].update({Habitat.water})
             elif t == Species.fish:
-                all_habs.append(Habitat.water)
+                all_habs.append({Habitat.water})
             elif t == Species.molusc:
-                all_habs.append(Habitat.land)
+                all_habs.append({Habitat.land})
                 if x["aquatic"] == 1:
-                    all_habs[-1].update(Habitat.water)
+                    all_habs[-1].update({Habitat.water})
             return all_habs + [t]
 
         n = 20

{ripple_down_rules-0.0.4 → ripple_down_rules-0.0.6}/test/test_rdr_alchemy.py

@@ -116,7 +116,7 @@ class TestAlchemyRDR(TestCase):
         for case, attributes, targets in zip(self.all_cases[:n], all_attributes, habitat_targets):
             for attr, target in zip(attributes, targets):
                 case_queries.append(CaseQuery(case, attr, target=target))
-        grdr.fit(case_queries, expert=expert, animate_tree=draw_tree, n_iter=n)
+        grdr.fit(case_queries, expert=expert, animate_tree=draw_tree)
         for rule in grdr.start_rules:
             render_tree(rule, use_dot_exporter=True,
                         filename=self.test_results_dir + f"/grdr_{type(rule.conclusion).__name__}")