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

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

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

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.0.8"
+version = "0.0.10"
 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.8 → ripple_down_rules-0.0.10}/src/ripple_down_rules/datasets.py

@@ -9,7 +9,7 @@ from sqlalchemy.orm import MappedAsDataclass, Mapped, mapped_column, relationshi
 from typing_extensions import Tuple, List, Set, Optional
 from ucimlrepo import fetch_ucirepo
 
-from .datastructures import Case, create_rows_from_dataframe, Category, Column
+from .datastructures import Case, create_cases_from_dataframe, Category, CaseAttribute
 
 
 def load_cached_dataset(cache_file):
@@ -77,7 +77,7 @@ def load_zoo_dataset(cache_file: Optional[str] = None) -> Tuple[List[Case], List
     y = zoo['targets']
     # get ids as list of strings
     ids = zoo['ids'].values.flatten()
-    all_cases = create_rows_from_dataframe(X, "Animal")
+    all_cases = create_cases_from_dataframe(X)
 
     category_names = ["mammal", "bird", "reptile", "fish", "amphibian", "insect", "molusc"]
     category_id_to_name = {i + 1: name for i, name in enumerate(category_names)}

{ripple_down_rules-0.0.8 → ripple_down_rules-0.0.10}/src/ripple_down_rules/datastructures/__init__.py

@@ -1,4 +1,4 @@
 from .enums import *
 from .dataclasses import *
 from .callable_expression import *
-from .table import *
+from .case import *

{ripple_down_rules-0.0.8 → ripple_down_rules-0.0.10}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -7,7 +7,7 @@ from _ast import AST
 from sqlalchemy.orm import Session
 from typing_extensions import Type, Optional, Any, List, Union, Tuple, Dict, Set
 
-from .table import create_row, Row
+from .case import create_case, Case
 from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string
 
 
@@ -128,8 +128,8 @@ class CallableExpression(SubclassJSONSerializer):
 
     def __call__(self, case: Any, **kwargs) -> Any:
         try:
-            if not isinstance(case, Row):
-                case = create_row(case, max_recursion_idx=3)
+            if not isinstance(case, Case):
+                case = create_case(case, max_recursion_idx=3)
             output = eval(self.code)
             if self.conclusion_type:
                 assert isinstance(output, self.conclusion_type), (f"Expected output type {self.conclusion_type},"

ripple_down_rules-0.0.8/src/ripple_down_rules/datastructures/table.py → ripple_down_rules-0.0.10/src/ripple_down_rules/datastructures/case.py

@@ -1,44 +1,40 @@
 from __future__ import annotations
 
-import os
-import time
-from abc import ABC
 from collections import UserDict
-from copy import deepcopy, copy
 from dataclasses import dataclass
 from enum import Enum
 
 from pandas import DataFrame
 from sqlalchemy import MetaData
 from sqlalchemy.orm import DeclarativeBase as SQLTable, MappedColumn as SQLColumn, registry
-from typing_extensions import Any, Optional, Dict, Type, Set, Hashable, Union, List, TYPE_CHECKING, Tuple, Self
+from typing_extensions import Any, Optional, Dict, Type, Set, Hashable, Union, List, TYPE_CHECKING
 
-from ..utils import make_set, row_to_dict, table_rows_as_str, get_value_type_from_type_hint, make_list, \
-    SubclassJSONSerializer
+from ..utils import make_set, row_to_dict, table_rows_as_str, get_value_type_from_type_hint, SubclassJSONSerializer
 
 if TYPE_CHECKING:
     from ripple_down_rules.rules import Rule
     from .callable_expression import CallableExpression
 
 
-class Row(UserDict, SubclassJSONSerializer):
+class Case(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.
     """
 
-    def __init__(self, id_: Optional[Hashable] = None, **kwargs):
+    def __init__(self, _id: Optional[Hashable] = None, _type: Optional[Type] = None, **kwargs):
         """
         Create a new row.
 
-        :param id_: The id of the row.
+        :param _id: The id of the row.
         :param kwargs: The attributes of the row.
         """
         super().__init__(kwargs)
-        self.id_ = id_ if id_ else id(self)
+        self._id = _id if _id else id(self)
+        self._type = _type
 
     @classmethod
-    def from_obj(cls, obj: Any, obj_name: Optional[str] = None, max_recursion_idx: int = 3) -> Row:
+    def from_obj(cls, obj: Any, obj_name: Optional[str] = None, max_recursion_idx: int = 3) -> Case:
         """
         Create a row from an object.
 
@@ -47,7 +43,7 @@ class Row(UserDict, SubclassJSONSerializer):
         :param obj_name: The name of the object.
         :return: The row of the object.
         """
-        return create_row(obj, max_recursion_idx=max_recursion_idx, obj_name=obj_name)
+        return create_case(obj, max_recursion_idx=max_recursion_idx, obj_name=obj_name)
 
     def __getitem__(self, item: str) -> Any:
         return super().__getitem__(item.lower())
@@ -74,30 +70,22 @@ class Row(UserDict, SubclassJSONSerializer):
     def __delitem__(self, key):
         super().__delitem__(key.lower())
 
-    def __eq__(self, other):
-        if not isinstance(other, (Row, dict, UserDict)):
-            return False
-        elif isinstance(other, (dict, UserDict)):
-            return super().__eq__(Row(other))
-        else:
-            return super().__eq__(other)
-
     def __hash__(self):
-        return self.id_
+        return self._id
 
     def _to_json(self) -> Dict[str, Any]:
         serializable = {k: v for k, v in self.items() if not k.startswith("_")}
-        serializable["_id"] = self.id_
+        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:
+    def _from_json(cls, data: Dict[str, Any]) -> Case:
         id_ = data.pop("_id")
-        return cls(id_=id_, **data)
+        return cls(_id=id_, **data)
 
 
 @dataclass
-class ColumnValue(SubclassJSONSerializer):
+class CaseAttributeValue(SubclassJSONSerializer):
     """
     A column value is a value in a column.
     """
@@ -111,7 +99,7 @@ class ColumnValue(SubclassJSONSerializer):
     """
 
     def __eq__(self, other):
-        if not isinstance(other, ColumnValue):
+        if not isinstance(other, CaseAttributeValue):
             return False
         return self.value == other.value
 
@@ -122,58 +110,58 @@ class ColumnValue(SubclassJSONSerializer):
         return {"id": self.id, "value": self.value}
 
     @classmethod
-    def _from_json(cls, data: Dict[str, Any]) -> ColumnValue:
+    def _from_json(cls, data: Dict[str, Any]) -> CaseAttributeValue:
         return cls(id=data["id"], value=data["value"])
 
 
-class Column(set, SubclassJSONSerializer):
+class CaseAttribute(set, SubclassJSONSerializer):
     nullable: bool = True
     """
-    A boolean indicating whether the column can be None or not.
+    A boolean indicating whether the case attribute can be None or not.
     """
     mutually_exclusive: bool = False
     """
-    A boolean indicating whether the column is mutually exclusive or not. (i.e. can only have one value)
+    A boolean indicating whether the case attribute is mutually exclusive or not. (i.e. can only have one value)
     """
 
-    def __init__(self, values: Set[ColumnValue]):
+    def __init__(self, values: Set[CaseAttributeValue]):
         """
-        Create a new column.
+        Create a new case attribute.
 
-        :param values: The values of the column.
+        :param values: The values of the case attribute.
         """
-        values = self._type_cast_values_to_set_of_column_values(values)
-        self.id_value_map: Dict[Hashable, Union[ColumnValue, Set[ColumnValue]]] = {id(v): v for v in values}
+        values = self._type_cast_values_to_set_of_case_attribute_values(values)
+        self.id_value_map: Dict[Hashable, Union[CaseAttributeValue, Set[CaseAttributeValue]]] = {id(v): v for v in values}
         super().__init__([v.value for v in values])
 
     @staticmethod
-    def _type_cast_values_to_set_of_column_values(values: Set[Any]) -> Set[ColumnValue]:
+    def _type_cast_values_to_set_of_case_attribute_values(values: Set[Any]) -> Set[CaseAttributeValue]:
         """
-        Type cast values to a set of column values.
+        Type cast values to a set of case attribute values.
 
         :param values: The values to type cast.
         """
         values = make_set(values)
-        if len(values) > 0 and not isinstance(next(iter(values)), ColumnValue):
-            values = {ColumnValue(id(values), v) for v in values}
+        if len(values) > 0 and not isinstance(next(iter(values)), CaseAttributeValue):
+            values = {CaseAttributeValue(id(values), v) for v in values}
         return values
 
     @classmethod
-    def from_obj(cls, values: Set[Any], row_obj: Optional[Any] = None) -> Column:
+    def from_obj(cls, values: Set[Any], row_obj: Optional[Any] = None) -> CaseAttribute:
         id_ = id(row_obj) if row_obj else id(values)
         values = make_set(values)
-        return cls({ColumnValue(id_, v) for v in values})
+        return cls({CaseAttributeValue(id_, v) for v in values})
 
     @property
     def as_dict(self) -> Dict[str, Any]:
         """
-        Get the column as a dictionary.
+        Get the case attribute as a dictionary.
 
-        :return: The column as a dictionary.
+        :return: The case attribute as a dictionary.
         """
         return {self.__class__.__name__: self}
 
-    def filter_by(self, condition: CallableExpression) -> Column:
+    def filter_by(self, condition: CallableExpression) -> CaseAttribute:
         """
         Filter the column by a condition.
 
@@ -200,118 +188,116 @@ class Column(set, SubclassJSONSerializer):
                 for id_, v in self.id_value_map.items()}
 
     @classmethod
-    def _from_json(cls, data: Dict[str, Any]) -> Column:
-        return cls({ColumnValue.from_json(v) for id_, v in data.items()})
+    def _from_json(cls, data: Dict[str, Any]) -> CaseAttribute:
+        return cls({CaseAttributeValue.from_json(v) for id_, v in data.items()})
 
 
-def create_rows_from_dataframe(df: DataFrame, name: Optional[str] = None) -> List[Row]:
+def create_cases_from_dataframe(df: DataFrame) -> List[Case]:
     """
-    Create a row from a pandas DataFrame.
+    Create cases from a pandas DataFrame.
 
-    :param df: The DataFrame to create a row from.
-    :param name: The name of the DataFrame.
-    :return: The row of the DataFrame.
+    :param df: The DataFrame to create cases from.
+    :return: The cases of the DataFrame.
     """
-    rows = []
-    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}
-        rows.append(Row(id_=row_id, **row))
-    return rows
+    cases = []
+    attribute_names = list(df.columns)
+    for row_id, case in df.iterrows():
+        case = {col_name: case[col_name].item() for col_name in attribute_names}
+        cases.append(Case(_id=row_id, _type=DataFrame, **case))
+    return cases
 
 
-def create_row(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
-               obj_name: Optional[str] = None, parent_is_iterable: bool = False) -> Row:
+def create_case(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
+                obj_name: Optional[str] = None, parent_is_iterable: bool = False) -> Case:
     """
-    Create a table from an object.
+    Create a case from an object.
 
-    :param obj: The object to create a table from.
+    :param obj: The object to create a case from.
     :param recursion_idx: The current recursion index.
     :param max_recursion_idx: The maximum recursion index to prevent infinite recursion.
     :param obj_name: The name of the object.
     :param parent_is_iterable: Boolean indicating whether the parent object is iterable or not.
-    :return: The table of the object.
+    :return: The case that represents the object.
     """
-    if isinstance(obj, Row):
+    if isinstance(obj, DataFrame):
+        return create_cases_from_dataframe(obj)
+    if isinstance(obj, Case):
         return obj
     if ((recursion_idx > max_recursion_idx) or (obj.__class__.__module__ == "builtins")
             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))
+        return Case(_id=id(obj), _type=obj.__class__,
+                    **{obj_name or obj.__class__.__name__: make_set(obj) if parent_is_iterable else obj})
+    case = Case(_id=id(obj), _type=obj.__class__)
     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)
-    return row
+        case = create_or_update_case_from_attribute(attr_value, attr, obj, attr, recursion_idx,
+                                                    max_recursion_idx, parent_is_iterable, case)
+    return case
 
 
-def create_or_update_row_from_attribute(attr_value: Any, name: str, obj: Any, obj_name: Optional[str] = None,
-                                        recursion_idx: int = 0, max_recursion_idx: int = 1,
-                                        parent_is_iterable: bool = False,
-                                        row: Optional[Row] = None) -> Row:
+def create_or_update_case_from_attribute(attr_value: Any, name: str, obj: Any, obj_name: Optional[str] = None,
+                                         recursion_idx: int = 0, max_recursion_idx: int = 1,
+                                         parent_is_iterable: bool = False,
+                                         case: Optional[Case] = None) -> Case:
     """
-    Get a reference column and its table.
+    Create or update a case from an attribute of the object that the case represents.
 
-    :param attr_value: The attribute value to get the column and table from.
+    :param attr_value: The attribute value.
     :param name: The name of the attribute.
     :param obj: The parent object of the attribute.
     :param obj_name: The parent object name.
     :param recursion_idx: The recursion index to prevent infinite recursion.
     :param max_recursion_idx: The maximum recursion index.
     :param parent_is_iterable: Boolean indicating whether the parent object is iterable or not.
-    :param row: The row to update.
-    :return: A reference column and its table.
+    :param case: The case to update.
+    :return: The updated/created case.
     """
-    if row is None:
-        row = Row(id_=id(obj))
+    if case is None:
+        case = Case(_id=id(obj), _type=obj.__class__)
     if isinstance(attr_value, (dict, UserDict)):
-        row.update({f"{obj_name}.{k}": v for k, v in attr_value.items()})
+        case.update({f"{obj_name}.{k}": v for k, v in attr_value.items()})
     if hasattr(attr_value, "__iter__") and not isinstance(attr_value, str):
-        column, attr_row = create_column_and_row_from_iterable_attribute(attr_value, name, obj, obj_name,
-                                                                         recursion_idx=recursion_idx + 1,
-                                                                         max_recursion_idx=max_recursion_idx)
-        row[obj_name] = column
+        column = create_case_attribute_from_iterable_attribute(attr_value, name, obj, obj_name,
+                                                               recursion_idx=recursion_idx + 1,
+                                                               max_recursion_idx=max_recursion_idx)
+        case[obj_name] = column
     else:
-        row[obj_name] = make_set(attr_value) if parent_is_iterable else attr_value
-    return row
+        case[obj_name] = make_set(attr_value) if parent_is_iterable else attr_value
+    return case
 
 
-def create_column_and_row_from_iterable_attribute(attr_value: Any, name: str, obj: Any, obj_name: Optional[str] = None,
+def create_case_attribute_from_iterable_attribute(attr_value: Any, name: str, obj: Any, obj_name: Optional[str] = None,
                                                   recursion_idx: int = 0,
-                                                  max_recursion_idx: int = 1) -> Tuple[Column, Row]:
+                                                  max_recursion_idx: int = 1) -> CaseAttribute:
     """
-    Get a table from an iterable.
+    Get a case attribute from an iterable attribute.
 
-    :param attr_value: The iterable attribute to get the table from.
-    :param name: The name of the table.
+    :param attr_value: The iterable attribute to get the case from.
+    :param name: The name of the case.
     :param obj: The parent object of the iterable.
     :param obj_name: The parent object name.
     :param recursion_idx: The recursion index to prevent infinite recursion.
     :param max_recursion_idx: The maximum recursion index.
-    :return: A table of the iterable.
+    :return: A case attribute that represents the original iterable attribute.
     """
     values = attr_value.values() if isinstance(attr_value, (dict, UserDict)) else attr_value
-    range_ = {type(list(values)[0])} if len(values) > 0 else set()
-    if len(range_) == 0:
-        range_ = make_set(get_value_type_from_type_hint(name, obj))
-    if not range_:
-        raise ValueError(f"Could not determine the range of {name} in {obj}.")
-    attr_row = Row(id_=id(attr_value))
-    column = Column.from_obj(values, row_obj=obj)
+    _type = type(list(values)[0]) if len(values) > 0 else get_value_type_from_type_hint(name, obj)
+    attr_case = Case(_id=id(attr_value), _type=_type)
+    case_attr = CaseAttribute.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)
-    for sub_attr, val in attr_row.items():
-        setattr(column, sub_attr, val)
-    return column, attr_row
+        sub_attr_case = create_case(val, recursion_idx=recursion_idx,
+                                    max_recursion_idx=max_recursion_idx,
+                                    obj_name=obj_name, parent_is_iterable=True)
+        attr_case.update(sub_attr_case)
+    for sub_attr, val in attr_case.items():
+        setattr(case_attr, sub_attr, val)
+    return case_attr
 
 
-def show_current_and_corner_cases(case: Any, targets: Optional[Union[List[Column], List[SQLColumn]]] = None,
-                                  current_conclusions: Optional[Union[List[Column], List[SQLColumn]]] = None,
+def show_current_and_corner_cases(case: Any, targets: Optional[Union[List[CaseAttribute], List[SQLColumn]]] = None,
+                                  current_conclusions: Optional[Union[List[CaseAttribute], List[SQLColumn]]] = None,
                                   last_evaluated_rule: Optional[Rule] = None) -> None:
     """
     Show the data of the new case and if last evaluated rule exists also show that of the corner case.
@@ -351,6 +337,3 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Union[List[Column
     case_dict.update(targets)
     case_dict.update(current_conclusions)
     print(table_rows_as_str(case_dict))
-
-
-Case = Row

{ripple_down_rules-0.0.8 → ripple_down_rules-0.0.10}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from sqlalchemy.orm import DeclarativeBase as SQLTable
 from typing_extensions import Any, Optional, Type
 
-from .table import create_row, Case
+from .case import create_case, Case
 from ..utils import get_attribute_name, copy_case
 
 
@@ -50,7 +50,7 @@ class CaseQuery:
         self.attribute_name = attribute_name
 
         if not isinstance(case, (Case, SQLTable)):
-            case = create_row(case, max_recursion_idx=3)
+            case = create_case(case, max_recursion_idx=3)
         self.case = case
 
         self.attribute = getattr(self.case, self.attribute_name) if self.attribute_name else None

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

@@ -6,8 +6,8 @@ from abc import ABC, abstractmethod
 from sqlalchemy.orm import DeclarativeBase as SQLTable, MappedColumn as SQLColumn, Session
 from typing_extensions import Optional, Dict, TYPE_CHECKING, List, Tuple, Type, Union, Any
 
-from .datastructures import (Case, PromptFor, CallableExpression, Column, CaseQuery)
-from .datastructures.table import show_current_and_corner_cases
+from .datastructures import (Case, PromptFor, CallableExpression, CaseAttribute, CaseQuery)
+from .datastructures.case import show_current_and_corner_cases
 from .prompt import prompt_user_for_expression, prompt_user_about_case
 from .utils import get_all_subclasses, is_iterable
 
@@ -30,13 +30,13 @@ class Expert(ABC):
     """
     A flag to indicate if the expert should use loaded answers or not.
     """
-    known_categories: Optional[Dict[str, Type[Column]]] = None
+    known_categories: Optional[Dict[str, Type[CaseAttribute]]] = None
     """
     The known categories (i.e. Column types) to use.
     """
 
     @abstractmethod
-    def ask_for_conditions(self, x: Case, targets: List[Column], last_evaluated_rule: Optional[Rule] = None) \
+    def ask_for_conditions(self, x: Case, targets: List[CaseAttribute], last_evaluated_rule: Optional[Rule] = None) \
             -> CallableExpression:
         """
         Ask the expert to provide the differentiating features between two cases or unique features for a case
@@ -50,8 +50,8 @@ class Expert(ABC):
         pass
 
     @abstractmethod
-    def ask_for_extra_conclusions(self, x: Case, current_conclusions: List[Column]) \
-            -> Dict[Column, CallableExpression]:
+    def ask_for_extra_conclusions(self, x: Case, current_conclusions: List[CaseAttribute]) \
+            -> Dict[CaseAttribute, CallableExpression]:
         """
         Ask the expert to provide extra conclusions for a case by providing a pair of category and conditions for
         that category.
@@ -63,9 +63,9 @@ class Expert(ABC):
         pass
 
     @abstractmethod
-    def ask_if_conclusion_is_correct(self, x: Case, conclusion: Column,
-                                     targets: Optional[List[Column]] = None,
-                                     current_conclusions: Optional[List[Column]] = None) -> bool:
+    def ask_if_conclusion_is_correct(self, x: Case, conclusion: CaseAttribute,
+                                     targets: Optional[List[CaseAttribute]] = None,
+                                     current_conclusions: Optional[List[CaseAttribute]] = None) -> bool:
         """
         Ask the expert if the conclusion is correct.
 
@@ -125,14 +125,14 @@ class Human(Expert):
             self.all_expert_answers = json.load(f)
 
     def ask_for_conditions(self, case: Case,
-                           targets: Union[List[Column], List[SQLColumn]],
+                           targets: Union[List[CaseAttribute], List[SQLColumn]],
                            last_evaluated_rule: Optional[Rule] = None) \
             -> CallableExpression:
         if not self.use_loaded_answers:
             show_current_and_corner_cases(case, targets, last_evaluated_rule=last_evaluated_rule)
         return self._get_conditions(case, targets)
 
-    def _get_conditions(self, case: Case, targets: List[Column]) \
+    def _get_conditions(self, case: Case, targets: List[CaseAttribute]) \
             -> CallableExpression:
         """
         Ask the expert to provide the differentiating features between two cases or unique features for a case
@@ -157,8 +157,8 @@ class Human(Expert):
                 self.all_expert_answers.append(user_input)
         return condition
 
-    def ask_for_extra_conclusions(self, case: Case, current_conclusions: List[Column]) \
-            -> Dict[Column, CallableExpression]:
+    def ask_for_extra_conclusions(self, case: Case, current_conclusions: List[CaseAttribute]) \
+            -> Dict[CaseAttribute, CallableExpression]:
         """
         Ask the expert to provide extra conclusions for a case by providing a pair of category and conditions for
         that category.
@@ -198,7 +198,7 @@ class Human(Expert):
             self.all_expert_answers.append(expert_input)
         return expression
 
-    def get_category_type(self, cat_name: str) -> Optional[Type[Column]]:
+    def get_category_type(self, cat_name: str) -> Optional[Type[CaseAttribute]]:
         """
         Get the category type from the known categories.
 
@@ -206,8 +206,8 @@ class Human(Expert):
         :return: The category type.
         """
         cat_name = cat_name.lower()
-        self.known_categories = get_all_subclasses(Column) if not self.known_categories else self.known_categories
-        self.known_categories.update(Column.registry)
+        self.known_categories = get_all_subclasses(CaseAttribute) if not self.known_categories else self.known_categories
+        self.known_categories.update(CaseAttribute.registry)
         category_type = None
         if cat_name in self.known_categories:
             category_type = self.known_categories[cat_name]
@@ -222,9 +222,9 @@ class Human(Expert):
         question = f"Can a case have multiple values of the new category {category_name}? (y/n):"
         return not self.ask_yes_no_question(question)
 
-    def ask_if_conclusion_is_correct(self, x: Case, conclusion: Column,
-                                     targets: Optional[List[Column]] = None,
-                                     current_conclusions: Optional[List[Column]] = None) -> bool:
+    def ask_if_conclusion_is_correct(self, x: Case, conclusion: CaseAttribute,
+                                     targets: Optional[List[CaseAttribute]] = None,
+                                     current_conclusions: Optional[List[CaseAttribute]] = None) -> bool:
         """
         Ask the expert if the conclusion is correct.
 

{ripple_down_rules-0.0.8 → ripple_down_rules-0.0.10}/src/ripple_down_rules/prompt.py

@@ -7,7 +7,7 @@ from prompt_toolkit.completion import WordCompleter
 from sqlalchemy.orm import DeclarativeBase as SQLTable, Session
 from typing_extensions import Any, List, Optional, Tuple, Dict, Union, Type
 
-from .datastructures import Case, PromptFor, CallableExpression, create_row, parse_string_to_expression
+from .datastructures import Case, PromptFor, CallableExpression, create_case, parse_string_to_expression
 
 
 def prompt_user_for_expression(case: Union[Case, SQLTable], prompt_for: PromptFor, target_name: str,
@@ -60,7 +60,7 @@ def get_completions(obj: Any) -> List[str]:
     # Define completer with all object attributes and comparison operators
     completions = ['==', '!=', '>', '<', '>=', '<=', 'in', 'not', 'and', 'or', 'is']
     completions += ["isinstance(", "issubclass(", "type(", "len(", "hasattr(", "getattr(", "setattr(", "delattr("]
-    completions += list(create_row(obj).keys())
+    completions += list(create_case(obj).keys())
     return completions
 
 

{ripple_down_rules-0.0.8 → ripple_down_rules-0.0.10}/src/ripple_down_rules/rdr.py

@@ -8,7 +8,7 @@ from ordered_set import OrderedSet
 from sqlalchemy.orm import DeclarativeBase as SQLTable, Session
 from typing_extensions import List, Optional, Dict, Type, Union, Any, Self, Tuple
 
-from .datastructures import Case, MCRDRMode, CallableExpression, Column, CaseQuery
+from .datastructures import Case, MCRDRMode, CallableExpression, CaseAttribute, 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, \
@@ -23,7 +23,7 @@ class RippleDownRules(ABC):
     """
     The figure to draw the tree on.
     """
-    expert_accepted_conclusions: Optional[List[Column]] = None
+    expert_accepted_conclusions: Optional[List[CaseAttribute]] = None
     """
     The conclusions that the expert has accepted, such that they are not asked again.
     """
@@ -37,11 +37,11 @@ class RippleDownRules(ABC):
         self.session = session
         self.fig: Optional[plt.Figure] = None
 
-    def __call__(self, case: Union[Case, SQLTable]) -> Column:
+    def __call__(self, case: Union[Case, SQLTable]) -> CaseAttribute:
         return self.classify(case)
 
     @abstractmethod
-    def classify(self, case: Union[Case, SQLTable]) -> Optional[Column]:
+    def classify(self, case: Union[Case, SQLTable]) -> Optional[CaseAttribute]:
         """
         Classify a case.
 
@@ -52,7 +52,7 @@ class RippleDownRules(ABC):
 
     @abstractmethod
     def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
-            -> Union[Column, CallableExpression]:
+            -> Union[CaseAttribute, CallableExpression]:
         """
         Fit the RDR on a case, and ask the expert for refinements or alternatives if the classification is incorrect by
         comparing the case with the target category.
@@ -118,7 +118,7 @@ class RippleDownRules(ABC):
             plt.show()
 
     @staticmethod
-    def calculate_precision_and_recall(pred_cat: List[Column], target: List[Column]) -> Tuple[List[bool], List[bool]]:
+    def calculate_precision_and_recall(pred_cat: List[CaseAttribute], target: List[CaseAttribute]) -> Tuple[List[bool], List[bool]]:
         """
         :param pred_cat: The predicted category.
         :param target: The target category.
@@ -131,7 +131,7 @@ class RippleDownRules(ABC):
         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:
+    def is_matching(self, pred_cat: List[CaseAttribute], target: List[CaseAttribute]) -> bool:
         """
         :param pred_cat: The predicted category.
         :param target: The target category.
@@ -179,7 +179,7 @@ RDR = RippleDownRules
 class SingleClassRDR(RippleDownRules, SubclassJSONSerializer):
 
     def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
-            -> Union[Column, CallableExpression]:
+            -> Union[CaseAttribute, CallableExpression]:
         """
         Classify a case, and ask the user for refinements or alternatives if the classification is incorrect by
         comparing the case with the target category if provided.
@@ -207,7 +207,7 @@ class SingleClassRDR(RippleDownRules, SubclassJSONSerializer):
 
         return self.classify(case)
 
-    def classify(self, case: Case) -> Optional[Column]:
+    def classify(self, case: Case) -> Optional[CaseAttribute]:
         """
         Classify a case by recursively evaluating the rules until a rule fires or the last rule is reached.
         """
@@ -225,18 +225,22 @@ class SingleClassRDR(RippleDownRules, SubclassJSONSerializer):
         """
         Write the tree of rules as source code to a file.
         """
-        case_type = self.start_rule.corner_case.__class__.__name__
-        case_module = self.start_rule.corner_case.__class__.__module__
+        case = self.start_rule.corner_case
+        if isinstance(case, Case):
+            case_type = case._type
+        else:
+            case_type = type(case)
+        case_module = case_type.__module__
         conclusion = self.start_rule.conclusion
         if isinstance(conclusion, CallableExpression):
             conclusion_types = [conclusion.conclusion_type]
-        elif isinstance(conclusion, Column):
+        elif isinstance(conclusion, CaseAttribute):
             conclusion_types = list(conclusion._value_range)
         else:
             conclusion_types = [type(conclusion)]
         imports = ""
         if case_module != "builtins":
-            imports += f"from {case_module} import {case_type}\n"
+            imports += f"from {case_module} import {case_type.__name__}\n"
         if len(conclusion_types) > 1:
             conclusion_name = "Union[" + ", ".join([c.__name__ for c in conclusion_types]) + "]"
         else:
@@ -244,11 +248,14 @@ class SingleClassRDR(RippleDownRules, SubclassJSONSerializer):
         for conclusion_type in conclusion_types:
             if conclusion_type.__module__ != "builtins":
                 imports += f"from {conclusion_type.__module__} import {conclusion_name}\n"
+        imports += "from ripple_down_rules.datastructures import Case, create_case\n"
         imports += "\n\n"
-        func_def = f"def classify_{conclusion_name.lower()}(case: {case_type}) -> {conclusion_name}:\n"
+        func_def = f"def classify_{conclusion_name.lower()}(case: {case_type.__name__}) -> {conclusion_name}:\n"
         with open(filename, "w") as f:
             f.write(imports)
             f.write(func_def)
+            f.write(f"{' '*4}if not isinstance(case, Case):\n"
+                    f"{' '*4}    case = create_case(case, recursion_idx=3)\n""")
             self.write_rules_as_source_code_to_file(self.start_rule, f, " " * 4)
 
     def write_rules_as_source_code_to_file(self, rule: SingleClassRule, file, parent_indent: str = ""):
@@ -287,7 +294,7 @@ class MultiClassRDR(RippleDownRules):
     """
     The evaluated rules in the classifier for one case.
     """
-    conclusions: Optional[List[Column]] = None
+    conclusions: Optional[List[CaseAttribute]] = None
     """
     The conclusions that the case belongs to.
     """
@@ -320,7 +327,7 @@ class MultiClassRDR(RippleDownRules):
         return self.conclusions
 
     def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None,
-                 add_extra_conclusions: bool = False) -> List[Union[Column, CallableExpression]]:
+                 add_extra_conclusions: bool = False) -> List[Union[CaseAttribute, CallableExpression]]:
         """
         Classify a case, and ask the user for stopping rules or classifying rules if the classification is incorrect
          or missing by comparing the case with the target category if provided.
@@ -448,7 +455,7 @@ class MultiClassRDR(RippleDownRules):
         :param target: The target category to compare the conclusion with.
         :return: Whether the conclusion is of the same class as the target category but has a different value.
         """
-        return conclusion.__class__ == target.__class__ and target.__class__ != Column
+        return conclusion.__class__ == target.__class__ and target.__class__ != CaseAttribute
 
     def conclusion_is_correct(self, case: Union[Case, SQLTable], target: Any, expert: Expert, evaluated_rule: Rule,
                               add_extra_conclusions: bool) -> bool:
@@ -597,7 +604,7 @@ class GeneralRDR(RippleDownRules):
         return conclusions
 
     def fit_case(self, case_queries: List[CaseQuery], expert: Optional[Expert] = None, **kwargs) \
-            -> List[Union[Column, CallableExpression]]:
+            -> List[Union[CaseAttribute, CallableExpression]]:
         """
         Fit the GRDR on a case, if the target is a new type of category, a new RDR is created for it,
         else the existing RDR of that type will be fitted on the case, and then classification is done and all
@@ -624,7 +631,7 @@ 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 is_iterable(target) and not isinstance(target, Column):
+            if is_iterable(target) and not isinstance(target, CaseAttribute):
                 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")
@@ -659,7 +666,7 @@ class GeneralRDR(RippleDownRules):
                 return MultiClassRDR()
             else:
                 return SingleClassRDR()
-        elif isinstance(attribute, Column):
+        elif isinstance(attribute, CaseAttribute):
             return SingleClassRDR() if attribute.mutually_exclusive else MultiClassRDR()
         else:
             return MultiClassRDR() if is_iterable(attribute) else SingleClassRDR()

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

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

@@ -15,9 +15,9 @@ src/ripple_down_rules.egg-info/dependency_links.txt
 src/ripple_down_rules.egg-info/top_level.txt
 src/ripple_down_rules/datastructures/__init__.py
 src/ripple_down_rules/datastructures/callable_expression.py
+src/ripple_down_rules/datastructures/case.py
 src/ripple_down_rules/datastructures/dataclasses.py
 src/ripple_down_rules/datastructures/enums.py
-src/ripple_down_rules/datastructures/table.py
 test/test_json_serialization.py
 test/test_rdr.py
 test/test_rdr_alchemy.py

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

@@ -6,7 +6,7 @@ from typing_extensions import List
 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
+    Case, CaseAttribute, Category, CaseQuery
 from ripple_down_rules.experts import Human
 from ripple_down_rules.rdr import SingleClassRDR, MultiClassRDR, GeneralRDR
 from ripple_down_rules.utils import render_tree, get_all_subclasses
@@ -183,7 +183,7 @@ class TestRDR(TestCase):
                               add_extra_conclusions=True, expert=expert)
         render_tree(mcrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + f"/mcrdr_extra_classify")
-        LivesOnlyOnLand = get_all_subclasses(Column)["LivesOnlyOnLand".lower()]
+        LivesOnlyOnLand = get_all_subclasses(CaseAttribute)["LivesOnlyOnLand".lower()]
         self.assertEqual(cats, [self.targets[50], LivesOnlyOnLand(True)])
 
         if save_answers:
@@ -206,7 +206,7 @@ class TestRDR(TestCase):
             expert.load_answers(file_name)
         mcrdr.fit(case_queries, add_extra_conclusions=True, expert=expert, n_iter=10, animate_tree=draw_tree)
         cats = mcrdr.classify(self.all_cases[50])
-        LivesOnlyOnLand = get_all_subclasses(Column)["LivesOnlyOnLand".lower()]
+        LivesOnlyOnLand = get_all_subclasses(CaseAttribute)["LivesOnlyOnLand".lower()]
         self.assertEqual(cats, [self.targets[50], LivesOnlyOnLand(True)])
         render_tree(mcrdr.start_rule, use_dot_exporter=True,
                     filename=self.test_results_dir + f"/mcrdr_extra")
@@ -246,7 +246,7 @@ class TestRDR(TestCase):
 
         grdr = GeneralRDR({type(fit_scrdr.start_rule.conclusion): fit_scrdr})
 
-        def get_habitat(x: Row, t: Category):
+        def get_habitat(x: Case, t: Category):
             all_habs = []
             if t == Species.mammal and x["aquatic"] == 0:
                 all_habs.append({Habitat.land})