ripple-down-rules 0.0.5__py3-none-any.whl → 0.0.6__py3-none-any.whl

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/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/datastructures/table.py

@@ -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/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
@@ -125,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/rdr.py

@@ -12,7 +12,7 @@ from .datastructures import Case, MCRDRMode, CallableExpression, Column, CaseQue
 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):
@@ -124,10 +124,12 @@ class RippleDownRules(ABC):
         :param target: The target category.
         :return: The precision and recall of the classifier.
         """
-        pred_cat = pred_cat if isinstance(pred_cat, list) else [pred_cat]
-        target = target if isinstance(target, list) else [target]
+        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
 
@@ -358,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
@@ -509,16 +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 = deepcopy(combined_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]):
         """
@@ -587,11 +589,11 @@ 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
@@ -624,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)
 
@@ -653,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.
 
@@ -668,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):
@@ -677,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)
@@ -686,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/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.5.dist-info → ripple_down_rules-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.5
+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.5.dist-info → ripple_down_rules-0.0.6.dist-info}/RECORD

@@ -1,21 +1,21 @@
 ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/datasets.py,sha256=QRB-1BdFTcUNuhgYEuXYx6qQOYlDu03_iLKDBqrcVrQ,4511
-ripple_down_rules/experts.py,sha256=DMTC-E2g1Fs43oyr30MGeGi5-VKBb3RojzzPa8DvCSA,12093
+ripple_down_rules/experts.py,sha256=F3Xx9G3DM-WSGkBql65G6Fztpt3bXfTXpAs06wuxYHQ,12109
 ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
 ripple_down_rules/prompt.py,sha256=lmREZRyleBTHrVtcf2j_48oc0v3VlxXYGhl6w1mk8qI,4208
-ripple_down_rules/rdr.py,sha256=nRhrHdQYmvXgfTFLyO_xxwe7GDYuUhaOqZlQtqSUrnE,33751
+ripple_down_rules/rdr.py,sha256=y5LmWYTBkq8r9aGcuYgwACE4yEC6PXRadRwcLBjCJoI,34228
 ripple_down_rules/rules.py,sha256=TLptqvA6I3QlQaVBTYchbgvXm17XWwFJoTmoN0diHm8,10348
-ripple_down_rules/utils.py,sha256=WlUXTf-B45SPEKpDBVb9QPQWS54250MGAY5xl9MIhR4,16944
+ripple_down_rules/utils.py,sha256=X0WOWPX57pejUtLchD4NyApQ9nKb6I313qVHlqTYWLs,17020
 ripple_down_rules/datastructures/__init__.py,sha256=wY9WqXavuE3wQ1YP65cs_SZyr7CEMB9tol-4oxgK9CM,104
 ripple_down_rules/datastructures/callable_expression.py,sha256=yEZ6OWzSiWsRtEz_5UquA0inmodFTOWqXWV_a2gg1cg,9110
-ripple_down_rules/datastructures/dataclasses.py,sha256=z_9B7Nj_MIf2Iyrs5VeUhXhYxwaqnuKVjgwxhZZTygY,2525
-ripple_down_rules/datastructures/enums.py,sha256=6Mh55_8QRuXyYZXtonWr01VBgLP-jYp91K_8hIgh8u8,4244
-ripple_down_rules/datastructures/table.py,sha256=Tq7savAaFoB7n7x6-u2Vz6NfvjLBzPxsqblR4cHujzM,23161
+ripple_down_rules/datastructures/dataclasses.py,sha256=FW3MMhGXTPa0XwIyLzGalrPwiltNeUqbGIawCAKDHGk,2448
+ripple_down_rules/datastructures/enums.py,sha256=ftcVTVkH0ttKr-kN9eCwAkQkdq04BLCgaZkpSIonAps,4238
+ripple_down_rules/datastructures/table.py,sha256=h6ZM_RBo6QPXDQiUvlCvO-I8orN_vaXyK2bYO0ns_4I,22816
 ripple_down_rules/datastructures/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/datastructures/generated/column/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/datastructures/generated/row/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules-0.0.5.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.0.5.dist-info/METADATA,sha256=qwUDSDi3YlBsg1RlYOEtFn5YQ3x7yNizCAKm72_8YPU,42518
-ripple_down_rules-0.0.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ripple_down_rules-0.0.5.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.0.5.dist-info/RECORD,,
+ripple_down_rules-0.0.6.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.0.6.dist-info/METADATA,sha256=qHgViKXWjjvMwi-ZxcILRJoBOipWHwGu2sCuTei06Sw,42518
+ripple_down_rules-0.0.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ripple_down_rules-0.0.6.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.0.6.dist-info/RECORD,,