ripple-down-rules 0.0.15__py3-none-any.whl → 0.1.0__py3-none-any.whl

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_cases_from_dataframe, Category, CaseAttribute
+from .datastructures import Case, create_cases_from_dataframe, Category
 
 
 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_cases_from_dataframe(X)
+    all_cases = create_cases_from_dataframe(X, name="Animal")
 
     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/datastructures/callable_expression.py

@@ -22,10 +22,22 @@ class VariableVisitor(ast.NodeVisitor):
     def __init__(self):
         self.variables = set()
         self.attributes: Dict[ast.Name, ast.Attribute] = {}
+        self.types = set()
+        self.callables = set()
         self.compares = list()
         self.binary_ops = list()
         self.all = list()
 
+    def visit_Constant(self, node):
+        self.all.append(node)
+        self.types.add(node)
+        self.generic_visit(node)
+
+    def visit_Call(self, node):
+        self.all.append(node)
+        self.callables.add(node)
+        self.generic_visit(node)
+
     def visit_Attribute(self, node):
         self.all.append(node)
         self.attributes[node.value] = node
@@ -51,6 +63,27 @@ class VariableVisitor(ast.NodeVisitor):
         self.generic_visit(node)
 
 
+def get_used_scope(code_str, scope):
+    # Parse the code into an AST
+    tree = ast.parse(code_str, mode='eval')
+
+    # Walk the AST to collect used variable names
+    class NameCollector(ast.NodeVisitor):
+        def __init__(self):
+            self.names = set()
+
+        def visit_Name(self, node):
+            if isinstance(node.ctx, ast.Load):  # We care only about variables being read
+                self.names.add(node.id)
+
+    collector = NameCollector()
+    collector.visit(tree)
+
+    # Filter the scope to include only used names
+    used_scope = {k: scope[k] for k in collector.names if k in scope}
+    return used_scope
+
+
 class CallableExpression(SubclassJSONSerializer):
     """
     A callable that is constructed from a string statement written by an expert.
@@ -85,7 +118,7 @@ class CallableExpression(SubclassJSONSerializer):
     """
 
     def __init__(self, user_input: str, conclusion_type: Optional[Type] = None, expression_tree: Optional[AST] = None,
-                 session: Optional[Session] = None):
+                 session: Optional[Session] = None, scope: Optional[Dict[str, Any]] = None):
         """
         Create a callable expression.
 
@@ -98,8 +131,17 @@ class CallableExpression(SubclassJSONSerializer):
         self.user_input: str = user_input
         self.parsed_user_input = self.parse_user_input(user_input, session)
         self.conclusion_type = conclusion_type
+        self.scope: Optional[Dict[str, Any]] = scope if scope is not None else {}
+        self.scope = get_used_scope(self.parsed_user_input, self.scope)
         self.update_expression(self.parsed_user_input, expression_tree)
 
+    def get_used_scope_in_user_input(self) -> Set[str]:
+        """
+        Get the used scope in the user input.
+        :return: The used scope in the user input.
+        """
+        return self.visitor.variables.union(self.visitor.attributes.keys())
+
     @staticmethod
     def parse_user_input(user_input: str, session: Optional[Session] = None) -> str:
         if ',' in user_input:
@@ -117,11 +159,6 @@ class CallableExpression(SubclassJSONSerializer):
         self.expression_tree: AST = expression_tree
         self.visitor = VariableVisitor()
         self.visitor.visit(expression_tree)
-        variables_str = self.visitor.variables
-        attributes_str = get_attributes_str(self.visitor)
-        for v in variables_str | attributes_str:
-            if not v.startswith("case."):
-                self.parsed_user_input = self.parsed_user_input.replace(v, f"case.{v}")
         self.expression_tree = parse_string_to_expression(self.parsed_user_input)
         self.compares_column_offset = [(c[0].col_offset, c[2].end_col_offset) for c in self.visitor.compares]
         self.code = compile_expression_to_code(self.expression_tree)
@@ -130,8 +167,9 @@ class CallableExpression(SubclassJSONSerializer):
         try:
             if not isinstance(case, Case):
                 case = create_case(case, max_recursion_idx=3)
-            output = eval(self.code)
-            if self.conclusion_type:
+            scope = {'case': case, **self.scope}
+            output = eval(self.code, scope)
+            if self.conclusion_type is not None:
                 assert isinstance(output, self.conclusion_type), (f"Expected output type {self.conclusion_type},"
                                                                   f" got {type(output)}")
             return output
@@ -163,11 +201,15 @@ class CallableExpression(SubclassJSONSerializer):
         return "\n".join(all_binary_ops) if len(all_binary_ops) > 0 else user_input
 
     def _to_json(self) -> Dict[str, Any]:
-        return {"user_input": self.user_input, "conclusion_type": get_full_class_name(self.conclusion_type)}
+        return {"user_input": self.user_input, "conclusion_type": get_full_class_name(self.conclusion_type),
+                "scope": {k: get_full_class_name(v) for k, v in self.scope.items()
+                          if hasattr(v, '__module__') and hasattr(v, '__name__')}
+                }
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> CallableExpression:
-        return cls(user_input=data["user_input"], conclusion_type=get_type_from_string(data["conclusion_type"]))
+        return cls(user_input=data["user_input"], conclusion_type=get_type_from_string(data["conclusion_type"]),
+                   scope={k: get_type_from_string(v) for k, v in data["scope"].items()})
 
 
 def compile_expression_to_code(expression_tree: AST) -> Any:

ripple_down_rules/datastructures/case.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections import UserDict
 from copy import copy, deepcopy
-from dataclasses import dataclass
+from dataclasses import dataclass, is_dataclass
 from enum import Enum
 
 from pandas import DataFrame
@@ -11,7 +11,7 @@ from sqlalchemy.orm import DeclarativeBase as SQLTable, MappedColumn as SQLColum
 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, SubclassJSONSerializer, \
-    get_full_class_name, get_type_from_string
+    get_full_class_name, get_type_from_string, make_list, is_iterable, serialize_dataclass
 
 if TYPE_CHECKING:
     from ripple_down_rules.rules import Rule
@@ -24,16 +24,19 @@ class Case(UserDict, SubclassJSONSerializer):
     the names of the attributes and the values are the attributes. All are stored in lower case.
     """
 
-    def __init__(self, _id: Optional[Hashable] = None, _type: Optional[Type] = None, **kwargs):
+    def __init__(self, _obj_type: Type, _id: Optional[Hashable] = None, _name: Optional[str] = None, **kwargs):
         """
         Create a new row.
 
+        :param _obj_type: The type of the object that the row represents.
         :param _id: The id of the row.
+        :param _name: The semantic name that describes the row.
         :param kwargs: The attributes of the row.
         """
         super().__init__(kwargs)
-        self._id = _id if _id else id(self)
-        self._type = _type
+        self._obj_type: Type = _obj_type
+        self._id: Hashable = _id if _id is not None else id(self)
+        self._name: str = _name if _name is not None else self._obj_type.__name__
 
     @classmethod
     def from_obj(cls, obj: Any, obj_name: Optional[str] = None, max_recursion_idx: int = 3) -> Case:
@@ -53,13 +56,14 @@ class Case(UserDict, SubclassJSONSerializer):
     def __setitem__(self, name: str, value: Any):
         name = name.lower()
         if name in self:
-            if isinstance(self[name], set):
-                self[name].update(make_set(value))
-            elif isinstance(value, set):
-                value.update(make_set(self[name]))
-                super().__setitem__(name, value)
+            if isinstance(self[name], list):
+                self[name].extend(make_list(value))
+            elif isinstance(value, list):
+                new_list = make_list(self[name])
+                new_list.extend(make_list(value))
+                super().__setitem__(name, new_list)
             else:
-                super().__setitem__(name, make_set([self[name], value]))
+                super().__setitem__(name, [self[name], value])
         else:
             super().__setitem__(name, value)
         setattr(self, name, self[name])
@@ -78,18 +82,24 @@ class Case(UserDict, SubclassJSONSerializer):
     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["_obj_type"] = get_full_class_name(self._obj_type)
+        serializable["_name"] = self._name
         for k, v in serializable.items():
             if isinstance(v, set):
-                serializable[k] = {'_type': get_full_class_name(set), 'value': list(v)}
+                serializable[k] = {'_type': get_full_class_name(set), 'value': serialize_dataclass(list(v))}
+            else:
+                serializable[k] = serialize_dataclass(v)
         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]) -> Case:
         id_ = data.pop("_id")
+        obj_type = get_type_from_string(data.pop("_obj_type"))
+        name = data.pop("_name")
         for k, v in data.items():
             if isinstance(v, dict) and "_type" in v:
                 data[k] = SubclassJSONSerializer.from_json(v)
-        return cls(_id=id_, **data)
+        return cls(_obj_type=obj_type, _id=id_, _name=name, **data)
 
 
 @dataclass
@@ -122,7 +132,7 @@ class CaseAttributeValue(SubclassJSONSerializer):
         return cls(id=data["id"], value=data["value"])
 
 
-class CaseAttribute(set, SubclassJSONSerializer):
+class CaseAttribute(list, SubclassJSONSerializer):
     nullable: bool = True
     """
     A boolean indicating whether the case attribute can be None or not.
@@ -132,33 +142,9 @@ class CaseAttribute(set, SubclassJSONSerializer):
     A boolean indicating whether the case attribute is mutually exclusive or not. (i.e. can only have one value)
     """
 
-    def __init__(self, values: Set[CaseAttributeValue]):
-        """
-        Create a new case attribute.
-
-        :param values: The values of the case attribute.
-        """
-        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_case_attribute_values(values: Set[Any]) -> Set[CaseAttributeValue]:
-        """
-        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)), 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) -> CaseAttribute:
-        id_ = id(row_obj) if row_obj else id(values)
-        values = make_set(values)
-        return cls({CaseAttributeValue(id_, v) for v in values})
+    def from_obj(cls, values: List[Any]) -> CaseAttribute:
+        return cls(make_list(values))
 
     @property
     def as_dict(self) -> Dict[str, Any]:
@@ -176,42 +162,43 @@ class CaseAttribute(set, SubclassJSONSerializer):
         :param condition: The condition to filter by.
         :return: The filtered column.
         """
-        return self.__class__({v for v in self if condition(v)})
+        return self.__class__([v for v in self if condition(v)])
 
     def __eq__(self, other):
-        if not isinstance(other, set):
-            return super().__eq__(make_set(other))
+        if not isinstance(other, list):
+            return super().__eq__(make_list(other))
         return super().__eq__(other)
 
     def __hash__(self):
-        return hash(tuple(self.id_value_map.values()))
+        return hash(id(self))
 
     def __str__(self):
         if len(self) == 0:
             return "None"
-        return str({v for v in self}) if len(self) > 1 else str(next(iter(self)))
+        return str([v for v in self]) if len(self) > 1 else str(next(iter(self)))
 
     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()}
+        return {str(i): v.to_json() if isinstance(v, SubclassJSONSerializer) else v
+                for i, v in enumerate(self)}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> CaseAttribute:
-        return cls({CaseAttributeValue.from_json(v) for id_, v in data.items()})
+        return cls([SubclassJSONSerializer.from_json(v) for _, v in data.items()])
 
 
-def create_cases_from_dataframe(df: DataFrame) -> List[Case]:
+def create_cases_from_dataframe(df: DataFrame, name: Optional[str] = None) -> List[Case]:
     """
     Create cases from a pandas DataFrame.
 
     :param df: The DataFrame to create cases from.
+    :param name: The semantic name of the DataFrame that describes the DataFrame.
     :return: The cases of the DataFrame.
     """
     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))
+        cases.append(Case(DataFrame, _id=row_id, _name=name, **case))
     return cases
 
 
@@ -228,19 +215,19 @@ def create_case(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
     :return: The case that represents the object.
     """
     if isinstance(obj, DataFrame):
-        return create_cases_from_dataframe(obj)
+        return create_cases_from_dataframe(obj, obj_name)
     if isinstance(obj, Case):
         return obj
     if ((recursion_idx > max_recursion_idx) or (obj.__class__.__module__ == "builtins")
             or (obj.__class__ in [MetaData, registry])):
-        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__)
+        return Case(type(obj), _id=id(obj), _name=obj_name,
+                    **{obj_name or obj.__class__.__name__: make_list(obj) if parent_is_iterable else obj})
+    case = Case(type(obj), _id=id(obj), _name=obj_name)
     for attr in dir(obj):
         if attr.startswith("_") or callable(getattr(obj, attr)):
             continue
         attr_value = getattr(obj, attr)
-        case = create_or_update_case_from_attribute(attr_value, attr, obj, attr, recursion_idx,
+        case = create_or_update_case_from_attribute(attr_value, attr, obj, obj_name, recursion_idx,
                                                     max_recursion_idx, parent_is_iterable, case)
     return case
 
@@ -263,16 +250,16 @@ def create_or_update_case_from_attribute(attr_value: Any, name: str, obj: Any, o
     :return: The updated/created case.
     """
     if case is None:
-        case = Case(_id=id(obj), _type=obj.__class__)
+        case = Case(type(obj), _id=id(obj), _name=obj_name)
     if isinstance(attr_value, (dict, UserDict)):
         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 = 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
+        case[name] = column
     else:
-        case[obj_name] = make_set(attr_value) if parent_is_iterable else attr_value
+        case[name] = make_list(attr_value) if parent_is_iterable else attr_value
     return case
 
 
@@ -290,22 +277,22 @@ def create_case_attribute_from_iterable_attribute(attr_value: Any, name: str, ob
     :param max_recursion_idx: The maximum recursion index.
     :return: A case attribute that represents the original iterable attribute.
     """
-    values = attr_value.values() if isinstance(attr_value, (dict, UserDict)) else attr_value
+    values = list(attr_value.values()) if isinstance(attr_value, (dict, UserDict)) else attr_value
     _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)
+    attr_case = Case(_type, _id=id(attr_value), _name=name)
+    case_attr = CaseAttribute(values)
     for idx, val in enumerate(values):
         sub_attr_case = create_case(val, recursion_idx=recursion_idx,
                                     max_recursion_idx=max_recursion_idx,
-                                    obj_name=obj_name, parent_is_iterable=True)
+                                    obj_name=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[CaseAttribute], List[SQLColumn]]] = None,
-                                  current_conclusions: Optional[Union[List[CaseAttribute], List[SQLColumn]]] = None,
+def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] = None,
+                                  current_conclusions: Optional[Dict[str, Any]] = 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.
@@ -316,12 +303,8 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Union[List[CaseAt
     :param last_evaluated_rule: The last evaluated rule in the RDR.
     """
     corner_case = None
-    if targets:
-        targets = targets if isinstance(targets, list) else [targets]
-    if current_conclusions:
-        current_conclusions = current_conclusions if isinstance(current_conclusions, list) else [current_conclusions]
-    targets = {f"target_{t.__class__.__name__}": t for t in targets} if targets else {}
-    current_conclusions = {c.__class__.__name__: c for c in current_conclusions} if current_conclusions else {}
+    targets = {f"target_{name}": value for name, value in targets.items()} if targets else {}
+    current_conclusions = {name: value for name, value in current_conclusions.items} if current_conclusions else {}
     if last_evaluated_rule:
         action = "Refinement" if last_evaluated_rule.fired else "Alternative"
         print(f"{action} needed for rule: {last_evaluated_rule}\n")

ripple_down_rules/datastructures/dataclasses.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
+import inspect
 from dataclasses import dataclass
 
 from sqlalchemy.orm import DeclarativeBase as SQLTable
-from typing_extensions import Any, Optional, Type
+from typing_extensions import Any, Optional, Type, List, Tuple, Set, Dict, TYPE_CHECKING
 
 from .case import create_case, Case
-from ..utils import get_attribute_name, copy_case
+from ..utils import get_attribute_name, copy_case, get_hint_for_attribute, typing_to_python_type
 
+if TYPE_CHECKING:
+    from . import CallableExpression
 
 @dataclass
 class CaseQuery:
@@ -20,56 +23,93 @@ class CaseQuery:
     """
     The case that the attribute belongs to.
     """
-    attribute: Optional[Any] = None
+    attribute_name: str
     """
-    The attribute itself.
+    The name of the attribute.
     """
-    targets: Optional[Any] = None
+    target: Optional[Any] = None
     """
     The target value of the attribute.
     """
-    attribute_name: Optional[str] = None
+    mutually_exclusive: bool = False
     """
-    The name of the attribute.
+    Whether the attribute can only take one value (i.e. True) or multiple values (i.e. False).
+    """
+    conditions: Optional[CallableExpression] = None
     """
-    attribute_type: Optional[Type] = None
+    The conditions that must be satisfied for the target value to be valid.
     """
-    The type of the attribute.
+    prediction: Optional[CallableExpression] = None
     """
-    relational_representation: Optional[str] = None
+    The predicted value of the attribute.
     """
-    The representation of the target value in relational form.
+    scope: Optional[Dict[str, Any]] = None
+    """
+    The global scope of the case query. This is used to evaluate the conditions and prediction, and is what is available
+    to the user when they are prompted for input. If it is not provided, it will be set to the global scope of the
+    caller.
     """
 
-    def __init__(self, case: Any, attribute: Optional[Any] = None, target: Optional[Any] = None,
-                 attribute_name: Optional[str] = None, attribute_type: Optional[Type] = None,
-                 relational_representation: Optional[str] = None):
+    def __init__(self, case: Any, attribute_name: str,
+                 target: Optional[Any] = None,
+                 mutually_exclusive: bool = False,
+                 conditions: Optional[CallableExpression] = None,
+                 prediction: Optional[CallableExpression] = None,
+                 scope: Optional[Dict[str, Any]] = None,):
+        self.original_case = case
+        self.case = self._get_case()
 
-        if attribute_name is None:
-            attribute_name = get_attribute_name(case, attribute, attribute_type, target)
         self.attribute_name = attribute_name
+        self.target = target
+        self.attribute_type = self._get_attribute_type()
+        self.mutually_exclusive = mutually_exclusive
+        self.conditions = conditions
+        self.prediction = prediction
+        self.scope = scope if scope is not None else inspect.currentframe().f_back.f_globals
 
-        if not isinstance(case, (Case, SQLTable)):
-            case = create_case(case, max_recursion_idx=3)
-        self.case = case
+    def _get_case(self) -> Any:
+        if not isinstance(self.original_case, (Case, SQLTable)):
+            return create_case(self.original_case, max_recursion_idx=3)
+        else:
+            return self.original_case
 
-        self.attribute = getattr(self.case, self.attribute_name) if self.attribute_name else None
-        self.attribute_type = type(self.attribute) if self.attribute else None
-        self.target = target
-        self.relational_representation = relational_representation
+    def _get_attribute_type(self) -> Type:
+        """
+        :return: The type of the attribute.
+        """
+        if self.target is not None:
+            return type(self.target)
+        elif hasattr(self.original_case, self.attribute_name):
+            hint, origin, args = get_hint_for_attribute(self.attribute_name, self.original_case)
+            if origin is not None:
+                return typing_to_python_type(origin)
+            elif hint is not None:
+                return typing_to_python_type(hint)
 
     @property
     def name(self):
-        return self.attribute_name if self.attribute_name else self.__class__.__name__
+        """
+        :return: The name of the case query.
+        """
+        return f"{self.case_name}.{self.attribute_name}"
+
+    @property
+    def case_name(self) -> str:
+        """
+        :return: The name of the case.
+        """
+        return self.case._name if isinstance(self.case, Case) else self.case.__class__.__name__
 
     def __str__(self):
-        if self.relational_representation:
-            return f"{self.name} |= {self.relational_representation}"
-        else:
-            return f"{self.target}"
+        header = f"CaseQuery: {self.name}"
+        target = f"Target: {self.name} |= {self.target if self.target is not None else '?'}"
+        prediction = f"Prediction: {self.name} |= {self.prediction if self.prediction is not None else '?'}"
+        conditions = f"Conditions: {self.conditions if self.conditions is not None else '?'}"
+        return "\n".join([header, target, prediction, conditions])
 
     def __repr__(self):
         return self.__str__()
 
     def __copy__(self):
-        return CaseQuery(copy_case(self.case), attribute_name=self.attribute_name, target=self.target)
+        return CaseQuery(copy_case(self.case), self.attribute_name, self.target, self.mutually_exclusive,
+                         self.conditions, self.prediction, self.scope)