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

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

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

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.0.6"
+version = "0.0.8"
 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.6 → ripple_down_rules-0.0.8}/src/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-0.0.6 → ripple_down_rules-0.0.8}/src/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-0.0.6 → ripple_down_rules-0.0.8}/src/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:
@@ -17,7 +19,14 @@ class Category(str, Enum):
 
     @property
     def as_dict(self):
-        return {self.__class__.__name__.lower(): 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-0.0.6 → ripple_down_rules-0.0.8}/src/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:
@@ -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,18 +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)
-    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
 
 
@@ -487,7 +299,7 @@ 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)
+    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,

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

@@ -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-0.0.6 → ripple_down_rules-0.0.8}/src/ripple_down_rules/rdr.py

@@ -128,8 +128,6 @@ class RippleDownRules(ABC):
         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
 
@@ -267,8 +265,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:

{ripple_down_rules-0.0.6 → ripple_down_rules-0.0.8}/src/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-0.0.6 → ripple_down_rules-0.0.8}/src/ripple_down_rules/utils.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib
+import json
 import logging
 from abc import abstractmethod
 from collections import UserDict
@@ -81,8 +82,27 @@ class SubclassJSONSerializer:
     'from_json' method.
     """
 
+    def to_json_file(self, filename: str):
+        """
+        Save the object to a json file.
+        """
+        data = self.to_json()
+        # save the json to a file
+        if not filename.endswith(".json"):
+            filename += ".json"
+        with open(filename, "w") as f:
+            json.dump(data, f, indent=4)
+        return data
+
     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
@@ -97,6 +117,19 @@ class SubclassJSONSerializer:
         """
         raise NotImplementedError()
 
+    @classmethod
+    def from_json_file(cls, filename: str):
+        """
+        Create an instance of the subclass from the data in the given json file.
+
+        :param filename: The filename of the json file.
+        """
+        if not filename.endswith(".json"):
+            filename += ".json"
+        with open(filename, "r") as f:
+            scrdr_json = json.load(f)
+        return cls.from_json(scrdr_json)
+
     @classmethod
     def from_json(cls, data: Dict[str, Any]) -> Self:
         """
@@ -117,6 +150,9 @@ class SubclassJSONSerializer:
 
         raise ValueError("Unknown type {}".format(data["_type"]))
 
+    save = to_json_file
+    load = from_json_file
+
 
 def copy_case(case: Union[Case, SQLTable]) -> Union[Case, SQLTable]:
     """

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.6
+Version: 0.0.8
 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.6 → ripple_down_rules-0.0.8}/src/ripple_down_rules.egg-info/SOURCES.txt

@@ -18,9 +18,6 @@ src/ripple_down_rules/datastructures/callable_expression.py
 src/ripple_down_rules/datastructures/dataclasses.py
 src/ripple_down_rules/datastructures/enums.py
 src/ripple_down_rules/datastructures/table.py
-src/ripple_down_rules/datastructures/generated/__init__.py
-src/ripple_down_rules/datastructures/generated/column/__init__.py
-src/ripple_down_rules/datastructures/generated/row/__init__.py
 test/test_json_serialization.py
 test/test_rdr.py
 test/test_rdr_alchemy.py

{ripple_down_rules-0.0.6 → ripple_down_rules-0.0.8}/test/test_json_serialization.py

@@ -19,17 +19,11 @@ class TestJSONSerialization(TestCase):
     def setUpClass(cls):
         cls.all_cases, cls.targets = load_zoo_dataset(cls.cache_dir + "/zoo_dataset.pkl")
 
-    def test_json_serialization(self):
+    def test_scrdr_json_serialization(self):
         scrdr = self.get_fit_scrdr()
-        scrdr_json = scrdr.to_json()
-        # save the json to a file
-        with open(f"{self.cache_dir}/scrdr.json", "w") as f:
-            json.dump(scrdr_json, f, indent=4)
-
-        # load the json from the file
-        with open(f"{self.cache_dir}/scrdr.json", "r") as f:
-            scrdr_json = json.load(f)
-        scrdr = SingleClassRDR.from_json(scrdr_json)
+        filename = f"{self.cache_dir}/scrdr.json"
+        scrdr.save(filename)
+        scrdr = SingleClassRDR.load(filename)
         for case, target in zip(self.all_cases, self.targets):
             cat = scrdr.classify(case)
             self.assertEqual(cat, target)

{ripple_down_rules-0.0.6 → ripple_down_rules-0.0.8}/test/test_rdr.py

@@ -3,7 +3,7 @@ from unittest import TestCase, skip
 
 from typing_extensions import List
 
-from ripple_down_rules.datasets import Habitat, SpeciesCol as Species
+from ripple_down_rules.datasets import Habitat, Species
 from ripple_down_rules.datasets import load_zoo_dataset
 from ripple_down_rules.datastructures import Case, MCRDRMode, \
     Row, Column, Category, CaseQuery
@@ -28,10 +28,6 @@ class TestRDR(TestCase):
             if not os.path.exists(test_dir):
                 os.makedirs(test_dir)
 
-    def tearDown(self):
-        Row._registry = {}
-        Column._registry = {}
-
     def test_classify_scrdr(self):
         use_loaded_answers = True
         save_answers = False

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

@@ -5,6 +5,7 @@ import sqlalchemy.orm
 from sqlalchemy import select
 from sqlalchemy.orm import MappedColumn as Column
 from typing_extensions import List, Sequence
+import pandas as pd
 
 from ripple_down_rules.datasets import Base, Animal, Species, get_dataset, Habitat, HabitatTable
 from ripple_down_rules.datastructures import CaseQuery
@@ -23,26 +24,35 @@ class TestAlchemyRDR(TestCase):
 
     @classmethod
     def setUpClass(cls):
+        # load dataset
         zoo = get_dataset(111, cls.cache_file)
 
-        # data (as pandas dataframes)
+        # get data and targets (as pandas dataframes)
         X = zoo['features']
         y = zoo['targets']
         names = zoo['ids'].values.flatten()
         X.loc[:, "name"] = names
 
-        engine = sqlalchemy.create_engine("sqlite:///:memory:")
-        Base.metadata.create_all(engine)
-        session = sqlalchemy.orm.Session(engine)
-        session.bulk_insert_mappings(Animal, X.to_dict(orient="records"))
-        session.commit()
-        cls.session = session
+        cls._init_session_and_insert_data(X)
+
+        # init cases
         query = select(Animal)
         cls.all_cases = cls.session.scalars(query).all()
+
+        # init targets
         category_names = ["mammal", "bird", "reptile", "fish", "amphibian", "insect", "molusc"]
         category_id_to_name = {i + 1: name for i, name in enumerate(category_names)}
         cls.targets = [Species(category_id_to_name[i]) for i in y.values.flatten()]
 
+    @classmethod
+    def _init_session_and_insert_data(cls, data: pd.DataFrame):
+        engine = sqlalchemy.create_engine("sqlite:///:memory:")
+        Base.metadata.create_all(engine)
+        session = sqlalchemy.orm.Session(engine)
+        session.bulk_insert_mappings(Animal, data.to_dict(orient="records"))
+        session.commit()
+        cls.session = session
+
     def test_fit_scrdr(self):
         use_loaded_answers = True
         draw_tree = False