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

ripple_down_rules/datasets.py

@@ -81,7 +81,8 @@ def load_zoo_dataset(cache_file: Optional[str] = None) -> Tuple[List[Case], List
 
     category_names = ["mammal", "bird", "reptile", "fish", "amphibian", "insect", "molusc"]
     category_id_to_name = {i + 1: name for i, name in enumerate(category_names)}
-    targets = [getattr(SpeciesCol, category_id_to_name[i]) for i in y.values.flatten()]
+    # targets = [getattr(SpeciesCol, category_id_to_name[i]) for i in y.values.flatten()]
+    targets = [Species.from_str(category_id_to_name[i]) for i in y.values.flatten()]
     return all_cases, targets
 
 
@@ -104,8 +105,8 @@ class Habitat(Category):
     air = "air"
 
 
-SpeciesCol = Column.create_from_enum(Species, mutually_exclusive=True)
-HabitatCol = Column.create_from_enum(Habitat, mutually_exclusive=False)
+# SpeciesCol = Column.create_from_enum(Species, mutually_exclusive=True)
+# HabitatCol = Column.create_from_enum(Habitat, mutually_exclusive=False)
 
 
 class Base(sqlalchemy.orm.DeclarativeBase):

ripple_down_rules/datastructures/callable_expression.py

@@ -162,9 +162,8 @@ class CallableExpression(SubclassJSONSerializer):
             prev_e = e
         return "\n".join(all_binary_ops) if len(all_binary_ops) > 0 else user_input
 
-    def to_json(self) -> Dict[str, Any]:
-        return {**SubclassJSONSerializer.to_json(self),
-                "user_input": self.user_input, "conclusion_type": get_full_class_name(self.conclusion_type)}
+    def _to_json(self) -> Dict[str, Any]:
+        return {"user_input": self.user_input, "conclusion_type": get_full_class_name(self.conclusion_type)}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> CallableExpression:

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

@@ -2,10 +2,12 @@ from __future__ import annotations
 
 from enum import auto, Enum
 
-from typing_extensions import List
+from typing_extensions import List, Dict, Any
 
+from ripple_down_rules.utils import SubclassJSONSerializer
 
-class Category(str, Enum):
+
+class Category(str, SubclassJSONSerializer, Enum):
 
     @classmethod
     def from_str(cls, value: str) -> Category:
@@ -19,6 +21,13 @@ class Category(str, Enum):
     def as_dict(self):
         return {self.__class__.__name__.lower(): self.value}
 
+    def _to_json(self) -> Dict[str, Any]:
+        return self.as_dict
+
+    @classmethod
+    def _from_json(cls, data: Dict[str, Any]) -> Category:
+        return cls.from_str(data[cls.__name__.lower()])
+
 
 class Stop(Category):
     """

ripple_down_rules/datastructures/table.py

@@ -21,165 +21,7 @@ if TYPE_CHECKING:
     from .callable_expression import CallableExpression
 
 
-class SubClassFactory:
-    """
-    A custom set class that is used to add other attributes to the set. This is similar to a table where the set is the
-    table, the attributes are the columns, and the values are the rows.
-    """
-    _value_range: set
-    """
-    The range of the attribute, this can be a set of possible values or a range of numeric values (int, float).
-    """
-    _registry: Dict[(str, type), Type[SubClassFactory]] = {}
-    """
-    A dictionary of all dynamically created subclasses of this class.
-    """
-    _generated_classes_dir: str = os.path.dirname(os.path.abspath(__file__)) + "/generated"
-
-    @classmethod
-    def create(cls, name: str, range_: set, class_attributes: Optional[Dict[str, Any]] = None,
-               default_values: bool = True,
-               attributes_type_hints: Optional[Dict[str, Type]] = None) -> Type[SubClassFactory]:
-        """
-        Create a new subclass.
-
-        :param name: The name of the subclass.
-        :param range_: The range of the subclass values.
-        :param class_attributes: The attributes of the new subclass.
-        :param default_values: Boolean indicating whether to add default values to the subclass attributes or not.
-        :param attributes_type_hints: The type hints of the subclass attributes.
-        :return: The new subclass.
-        """
-        existing_class = cls._get_and_update_subclass(name, range_)
-        if existing_class:
-            return existing_class
-
-        new_attribute_type = cls._create_class_in_new_python_file_and_import_it(name, range_, default_values,
-                                                                                class_attributes, attributes_type_hints)
-
-        cls.register(new_attribute_type)
-
-        return new_attribute_type
-
-    @classmethod
-    def _create_class_in_new_python_file_and_import_it(cls, name: str, range_: set, default_values: bool = True,
-                                                       class_attributes: Optional[Dict[str, Any]] = None,
-                                                       attributes_type_hints: Optional[Dict[str, Type]] = None)\
-            -> Type[SubClassFactory]:
-        def get_type_import(value_type: Any) -> Tuple[str, str]:
-            if value_type is type(None):
-                return "from types import NoneType\n", "NoneType"
-            elif value_type.__module__ != "builtins":
-                value_type_alias = f"{value_type.__name__}_"
-                return f"from {value_type.__module__} import {value_type.__name__} as {value_type_alias}\n", value_type_alias
-            else:
-                return "", value_type.__name__
-        attributes_type_hints = attributes_type_hints or {}
-        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 = 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:
-                new_import, value_type_name = get_type_import(type(value))
-            elif key in attributes_type_hints:
-                new_import, value_type_name = get_type_import(attributes_type_hints[key])
-            else:
-                new_import, value_type_name = "from typing_extensions import Any", "Any"
-            imports += new_import
-            if isinstance(value, set):
-                value_names = []
-                for v in value:
-                    if isinstance(v, type):
-                        new_import, v_name = get_type_import(v)
-                        imports += new_import
-                    else:
-                        v_name = str(v)
-                    value_names.append(v_name)
-                value_str = ", ".join(value_names)
-                new_value = "{" + value_str + "}"
-            elif isinstance(value, type):
-                new_import, value_name = get_type_import(value)
-                new_value = value_name
-                value_type_name = value_name
-            else:
-                new_value = value
-            if default_values or key == "_value_range":
-                class_code += f"    {key}: {value_type_name} = {new_value}\n"
-            else:
-                class_code += f"    {key}: {value_type_name}\n"
-        imports += "\n\n"
-        if issubclass(cls, Row):
-            folder_name = "row"
-        elif issubclass(cls, Column):
-            folder_name = "column"
-        else:
-            raise ValueError(f"Unknown class {cls}.")
-        # write the code to a file
-        with open(f"{cls._generated_classes_dir}/{folder_name}/{name.lower()}.py", "w") as f:
-            f.write(imports + class_code)
-
-        # import the class from the file
-        import_path = ".".join(cls.__module__.split(".")[:-1] + ["generated", folder_name, name.lower()])
-        time.sleep(0.3)
-        return __import__(import_path, fromlist=[name.lower()]).__dict__[name]
-
-    @classmethod
-    def _get_and_update_subclass(cls, name: str, range_: set) -> Optional[Type[SubClassFactory]]:
-        """
-        Get a subclass of the attribute class and update its range if necessary.
-
-        :param name: The name of the column.
-        :param range_: The range of the column values.
-        """
-        key = (name.lower(), cls)
-        if key in cls._registry:
-            if not cls._registry[key].is_within_range(range_):
-                if isinstance(cls._registry[key]._value_range, set):
-                    cls._registry[key]._value_range.update(range_)
-                else:
-                    raise ValueError(f"Range of {key} is different from {cls._registry[key]._value_range}.")
-            return cls._registry[key]
-
-    @classmethod
-    def register(cls, subclass: Type[SubClassFactory]):
-        """
-        Register a subclass of the attribute class, this is used to be able to dynamically create Attribute subclasses.
-
-        :param subclass: The subclass to register.
-        """
-        if not issubclass(subclass, SubClassFactory):
-            raise ValueError(f"{subclass} is not a subclass of CustomSet.")
-        if subclass not in cls._registry:
-            cls._registry[(subclass.__name__.lower(), cls)] = subclass
-        else:
-            raise ValueError(f"{subclass} is already registered.")
-
-    @classmethod
-    def is_within_range(cls, value: Any) -> bool:
-        """
-        Check if a value is within the range of the custom set.
-
-        :param value: The value to check.
-        :return: Boolean indicating whether the value is within the range or not.
-        """
-        if hasattr(value, "__iter__") and not isinstance(value, str):
-            if all(isinstance(val_range, type) and isinstance(v, val_range)
-                   for v in value for val_range in cls._value_range):
-                return True
-            else:
-                return set(value).issubset(cls._value_range)
-        elif isinstance(value, str):
-            return value.lower() in cls._value_range
-        else:
-            return value in cls._value_range
-
-    def __instancecheck__(self, instance):
-        return isinstance(instance, (SubClassFactory, *self._value_range))
-
-
-class Row(UserDict, SubClassFactory, SubclassJSONSerializer):
+class Row(UserDict, SubclassJSONSerializer):
     """
     A collection of attributes that represents a set of constraints on a case. This is a dictionary where the keys are
     the names of the attributes and the values are the attributes. All are stored in lower case.
@@ -193,7 +35,7 @@ class Row(UserDict, SubClassFactory, SubclassJSONSerializer):
         :param kwargs: The attributes of the row.
         """
         super().__init__(kwargs)
-        self.id = id_
+        self.id_ = id_ if id_ else id(self)
 
     @classmethod
     def from_obj(cls, obj: Any, obj_name: Optional[str] = None, max_recursion_idx: int = 3) -> Row:
@@ -219,10 +61,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)):
@@ -241,16 +83,12 @@ class Row(UserDict, SubClassFactory, SubclassJSONSerializer):
             return super().__eq__(other)
 
     def __hash__(self):
-        return hash(tuple(self.items()))
+        return self.id_
 
-    def __instancecheck__(self, instance):
-        return isinstance(instance, (dict, UserDict, Row)) or super().__instancecheck__(instance)
-
-    def to_json(self) -> Dict[str, Any]:
+    def _to_json(self) -> Dict[str, Any]:
         serializable = {k: v for k, v in self.items() if not k.startswith("_")}
-        serializable["_id"] = self.id
-        return {**SubclassJSONSerializer.to_json(self),
-                **{k: v.to_json() if isinstance(v, SubclassJSONSerializer) else v for k, v in serializable.items()}}
+        serializable["_id"] = self.id_
+        return {k: v.to_json() if isinstance(v, SubclassJSONSerializer) else v for k, v in serializable.items()}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Row:
@@ -280,16 +118,15 @@ class ColumnValue(SubclassJSONSerializer):
     def __hash__(self):
         return self.id
 
-    def to_json(self) -> Dict[str, Any]:
-        return {**SubclassJSONSerializer.to_json(self),
-                "id": self.id, "value": self.value}
+    def _to_json(self) -> Dict[str, Any]:
+        return {"id": self.id, "value": self.value}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> ColumnValue:
         return cls(id=data["id"], value=data["value"])
 
 
-class Column(set, SubClassFactory, SubclassJSONSerializer):
+class Column(set, SubclassJSONSerializer):
     nullable: bool = True
     """
     A boolean indicating whether the column can be None or not.
@@ -321,21 +158,6 @@ class Column(set, SubClassFactory, SubclassJSONSerializer):
             values = {ColumnValue(id(values), v) for v in values}
         return values
 
-    @classmethod
-    def create(cls, name: str, range_: set,
-               nullable: bool = True, mutually_exclusive: bool = False) -> Type[SubClassFactory]:
-        return super().create(name, range_, {"nullable": nullable, "mutually_exclusive": mutually_exclusive})
-
-    @classmethod
-    def create_from_enum(cls, category: Type[Enum], nullable: bool = True,
-                         mutually_exclusive: bool = False) -> Type[SubClassFactory]:
-        new_cls = cls.create(category.__name__.lower(), {category}, nullable=nullable,
-                             mutually_exclusive=mutually_exclusive)
-        for value in category:
-            value_column = cls.create(category.__name__.lower(), {value}, mutually_exclusive=mutually_exclusive)(value)
-            setattr(new_cls, value.name, value_column)
-        return new_cls
-
     @classmethod
     def from_obj(cls, values: Set[Any], row_obj: Optional[Any] = None) -> Column:
         id_ = id(row_obj) if row_obj else id(values)
@@ -373,12 +195,9 @@ class Column(set, SubClassFactory, SubclassJSONSerializer):
             return "None"
         return str({v for v in self}) if len(self) > 1 else str(next(iter(self)))
 
-    def __instancecheck__(self, instance):
-        return isinstance(instance, (set, self.__class__)) or super().__instancecheck__(instance)
-
-    def to_json(self) -> Dict[str, Any]:
-        return {**SubclassJSONSerializer.to_json(self),
-                **{id_: v.to_json() if isinstance(v, SubclassJSONSerializer) else v for id_, v in self.id_value_map.items()}}
+    def _to_json(self) -> Dict[str, Any]:
+        return {id_: v.to_json() if isinstance(v, SubclassJSONSerializer) else v
+                for id_, v in self.id_value_map.items()}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Column:
@@ -397,8 +216,7 @@ def create_rows_from_dataframe(df: DataFrame, name: Optional[str] = None) -> Lis
     col_names = list(df.columns)
     for row_id, row in df.iterrows():
         row = {col_name: row[col_name].item() for col_name in col_names}
-        row_cls = Row.create(name or df.__class__.__name__, make_set(type(df)), row, default_values=False)
-        rows.append(row_cls(id_=row_id, **row))
+        rows.append(Row(id_=row_id, **row))
     return rows
 
 
@@ -420,17 +238,12 @@ def create_row(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
             or (obj.__class__ in [MetaData, registry])):
         return Row(id_=id(obj), **{obj_name or obj.__class__.__name__: make_set(obj) if parent_is_iterable else obj})
     row = Row(id_=id(obj))
-    attributes_type_hints = {}
     for attr in dir(obj):
         if attr.startswith("_") or callable(getattr(obj, attr)):
             continue
         attr_value = getattr(obj, attr)
         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)
     return row
 
 
@@ -462,9 +275,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
 
 
@@ -489,15 +299,12 @@ def create_column_and_row_from_iterable_attribute(attr_value: Any, name: str, ob
     if not range_:
         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 = {}
+    column = Column.from_obj(values, row_obj=obj)
     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:
@@ -198,19 +198,6 @@ class Human(Expert):
             self.all_expert_answers.append(expert_input)
         return expression
 
-    def create_category_instance(self, cat_name: str, cat_value: Union[str, int, float, set]) -> Column:
-        """
-        Create a new category instance.
-
-        :param cat_name: The name of the category.
-        :param cat_value: The value of the category.
-        :return: A new instance of the category.
-        """
-        category_type = self.get_category_type(cat_name)
-        if not category_type:
-            category_type = self.create_new_category_type(cat_name)
-        return category_type(cat_value)
-
     def get_category_type(self, cat_name: str) -> Optional[Type[Column]]:
         """
         Get the category type from the known categories.
@@ -226,19 +213,6 @@ class Human(Expert):
             category_type = self.known_categories[cat_name]
         return category_type
 
-    def create_new_category_type(self, cat_name: str) -> Type[Column]:
-        """
-        Create a new category type.
-
-        :param cat_name: The name of the category.
-        :return: A new category type.
-        """
-        if self.ask_if_category_is_mutually_exclusive(cat_name):
-            category_type: Type[Column] = Column.create(cat_name, set(), mutually_exclusive=True)
-        else:
-            category_type: Type[Column] = Column.create(cat_name, set())
-        return category_type
-
     def ask_if_category_is_mutually_exclusive(self, category_name: str) -> bool:
         """
         Ask the expert if the new category can have multiple values.

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
 
@@ -265,8 +267,8 @@ class SingleClassRDR(RippleDownRules, SubclassJSONSerializer):
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent)
 
-    def to_json(self) -> Dict[str, Any]:
-        return {**SubclassJSONSerializer.to_json(self), "start_rule": self.start_rule.to_json()}
+    def _to_json(self) -> Dict[str, Any]:
+        return {"start_rule": self.start_rule.to_json()}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Self:
@@ -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/rules.py

@@ -195,9 +195,8 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
         if_clause = "elif" if self.weight == RDREdge.Alternative.value else "if"
         return f"{parent_indent}{if_clause} {self.conditions.parsed_user_input}:\n"
 
-    def to_json(self) -> Dict[str, Any]:
-        self.json_serialization = {**SubclassJSONSerializer.to_json(self),
-                                   "conditions": self.conditions.to_json(),
+    def _to_json(self) -> Dict[str, Any]:
+        self.json_serialization = {"conditions": self.conditions.to_json(),
                                    "conclusion": self.conclusion.to_json(),
                                    "parent": self.parent.json_serialization if self.parent else None,
                                    "corner_case": self.corner_case.to_json() if self.corner_case else None,

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".
@@ -64,7 +82,14 @@ class SubclassJSONSerializer:
     """
 
     def to_json(self) -> Dict[str, Any]:
-        return {"_type": get_full_class_name(self.__class__)}
+        return {"_type": get_full_class_name(self.__class__), **self._to_json()}
+
+    @abstractmethod
+    def _to_json(self) -> Dict[str, Any]:
+        """
+        Create a json dict from the object.
+        """
+        pass
 
     @classmethod
     @abstractmethod
@@ -350,20 +375,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.7.dist-info}/METADATA

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

@@ -0,0 +1,18 @@
+ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/datasets.py,sha256=p7WmLiAKcYtzLq87RJhzU_BHCdM-zKK71yldjyYNpUE,4602
+ripple_down_rules/experts.py,sha256=ajH46NXM6IREtWr2a-ZBxdKl4CFzSx5S7yktnyXgwnc,11089
+ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
+ripple_down_rules/prompt.py,sha256=lmREZRyleBTHrVtcf2j_48oc0v3VlxXYGhl6w1mk8qI,4208
+ripple_down_rules/rdr.py,sha256=dS_OqaGtP1PAKEe0h-dMy7JI9ycNuH_EIbHlh-Nz4Sg,34189
+ripple_down_rules/rules.py,sha256=R9wIyalXBc6fGogzy92OxsyKAtJdQwdso_Vs1evWZGU,10274
+ripple_down_rules/utils.py,sha256=VjpdJ5W-xK-TQttfpNIHRKpYK91vYjtQ22kgccQgVTQ,17183
+ripple_down_rules/datastructures/__init__.py,sha256=wY9WqXavuE3wQ1YP65cs_SZyr7CEMB9tol-4oxgK9CM,104
+ripple_down_rules/datastructures/callable_expression.py,sha256=lF8ag3-8oYuETAUohtRfviOpypSMQR-JEJGgR0Zhv3E,9055
+ripple_down_rules/datastructures/dataclasses.py,sha256=FW3MMhGXTPa0XwIyLzGalrPwiltNeUqbGIawCAKDHGk,2448
+ripple_down_rules/datastructures/enums.py,sha256=l0Eu-TeJ6qB2XHoJycXmUgLw-3yUebQ8SsEbW8bBZdM,4543
+ripple_down_rules/datastructures/table.py,sha256=G2ShfPmyiwfDXS-JY_jFD6nOx7OLuMr-GP--OCDGKYc,13733
+ripple_down_rules-0.0.7.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.0.7.dist-info/METADATA,sha256=fBb_rMvpmfAueLPCXvNs3IXLNX-COunhRnEq7iYkV5Y,42518
+ripple_down_rules-0.0.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ripple_down_rules-0.0.7.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.0.7.dist-info/RECORD,,

ripple_down_rules-0.0.5.dist-info/RECORD

@@ -1,21 +0,0 @@
-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/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/rules.py,sha256=TLptqvA6I3QlQaVBTYchbgvXm17XWwFJoTmoN0diHm8,10348
-ripple_down_rules/utils.py,sha256=WlUXTf-B45SPEKpDBVb9QPQWS54250MGAY5xl9MIhR4,16944
-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/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,,