ripple-down-rules 0.1.21__py3-none-any.whl → 0.1.62__py3-none-any.whl

ripple_down_rules/datasets.py

@@ -9,7 +9,8 @@ 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
+from .datastructures.case import Case, create_cases_from_dataframe
+from .datastructures.enums import Category
 
 
 def load_cached_dataset(cache_file):

ripple_down_rules/datastructures/__init__.py

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

ripple_down_rules/datastructures/callable_expression.py

@@ -4,11 +4,10 @@ import ast
 import logging
 from _ast import AST
 
-from sqlalchemy.orm import Session
 from typing_extensions import Type, Optional, Any, List, Union, Tuple, Dict, Set
 
 from .case import create_case, Case
-from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string
+from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string, conclusion_to_json, is_iterable
 
 
 class VariableVisitor(ast.NodeVisitor):
@@ -65,7 +64,8 @@ class VariableVisitor(ast.NodeVisitor):
 
 def get_used_scope(code_str, scope):
     # Parse the code into an AST
-    tree = ast.parse(code_str, mode='eval')
+    mode = 'exec' if code_str.startswith('def') else 'eval'
+    tree = ast.parse(code_str, mode=mode)
 
     # Walk the AST to collect used variable names
     class NameCollector(ast.NodeVisitor):
@@ -88,91 +88,56 @@ class CallableExpression(SubclassJSONSerializer):
     """
     A callable that is constructed from a string statement written by an expert.
     """
-    conclusion_type: Type
-    """
-    The type of the output of the callable, used for assertion.
-    """
-    expression_tree: AST
-    """
-    The AST tree parsed from the user input.
-    """
-    user_input: str
-    """
-    The input given by the expert.
-    """
-    session: Optional[Session]
-    """
-    The sqlalchemy orm session.
-    """
-    visitor: VariableVisitor
-    """
-    A visitor to extract all variables and comparisons from a python expression represented as an AST tree.
-    """
-    code: Any
-    """
-    The code that was compiled from the expression tree
-    """
-    compares_column_offset: List[int]
-    """
-    The start and end indices of each comparison in the string of user input.
-    """
 
-    def __init__(self, user_input: str, conclusion_type: Optional[Type] = None, expression_tree: Optional[AST] = None,
-                 session: Optional[Session] = None, scope: Optional[Dict[str, Any]] = None):
+    def __init__(self, user_input: Optional[str] = None, conclusion_type: Optional[Tuple[Type]] = None,
+                 expression_tree: Optional[AST] = None,
+                 scope: Optional[Dict[str, Any]] = None, conclusion: Optional[Any] = None):
         """
         Create a callable expression.
 
         :param user_input: The input given by the expert.
         :param conclusion_type: The type of the output of the callable.
         :param expression_tree: The AST tree parsed from the user input.
-        :param session: The sqlalchemy orm session.
+        :param scope: The scope to use for the callable expression.
+        :param conclusion: The conclusion to use for the callable expression.
         """
-        self.session = session
+        if user_input is None and conclusion is None:
+            raise ValueError("Either user_input or conclusion must be provided.")
+        self.conclusion: Optional[Any] = conclusion
         self.user_input: str = user_input
-        self.parsed_user_input = self.parse_user_input(user_input, session)
+        if conclusion_type is not None:
+            if is_iterable(conclusion_type):
+                conclusion_type = tuple(conclusion_type)
+            else:
+                conclusion_type = (conclusion_type,)
         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:
-            user_input = user_input.split(',')
-            user_input = [f"({u.strip()})" for u in user_input]
-            user_input = ' & '.join(user_input) if session else ' and '.join(user_input)
-        elif session:
-            user_input = user_input.replace(" and ", " & ")
-            user_input = user_input.replace(" or ", " | ")
-        return user_input
-
-    def update_expression(self, user_input: str, expression_tree: Optional[AST] = None):
-        if not expression_tree:
-            expression_tree = parse_string_to_expression(user_input)
-        self.expression_tree: AST = expression_tree
-        self.visitor = VariableVisitor()
-        self.visitor.visit(expression_tree)
-        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)
+        if conclusion is None:
+            self.scope = get_used_scope(self.user_input, self.scope)
+            self.expression_tree: AST = expression_tree if expression_tree else parse_string_to_expression(self.user_input)
+            self.code = compile_expression_to_code(self.expression_tree)
+            self.visitor = VariableVisitor()
+            self.visitor.visit(self.expression_tree)
 
     def __call__(self, case: Any, **kwargs) -> Any:
         try:
-            if not isinstance(case, Case):
-                case = create_case(case, max_recursion_idx=3)
-            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
+            if self.user_input is not None:
+                if not isinstance(case, Case):
+                    case = create_case(case, max_recursion_idx=3)
+                scope = {'case': case, **self.scope}
+                output = eval(self.code, scope)
+                if output is None:
+                    output = scope['_get_value'](case)
+                if self.conclusion_type is not None:
+                    if is_iterable(output) and not isinstance(output, self.conclusion_type):
+                        assert isinstance(list(output)[0], self.conclusion_type), (f"Expected output type {self.conclusion_type},"
+                                                                                 f" got {type(output)}")
+                    else:
+                        assert isinstance(output, self.conclusion_type), (f"Expected output type {self.conclusion_type},"
+                                                                          f" got {type(output)}")
+                return output
+            else:
+                return self.conclusion
         except Exception as e:
             raise ValueError(f"Error during evaluation: {e}")
 
@@ -181,35 +146,57 @@ class CallableExpression(SubclassJSONSerializer):
         Combine this callable expression with another callable expression using the 'and' operator.
         """
         new_user_input = f"({self.user_input}) and ({other.user_input})"
-        return CallableExpression(new_user_input, conclusion_type=self.conclusion_type, session=self.session)
+        return CallableExpression(new_user_input, conclusion_type=self.conclusion_type)
+
+    def __eq__(self, other):
+        """
+        Check if two callable expressions are equal.
+        """
+        if not isinstance(other, CallableExpression):
+            return False
+        return self.user_input == other.user_input and self.conclusion == other.conclusion
+
+    def __hash__(self):
+        """
+        Hash the callable expression.
+        """
+        conclusion_hash = self.conclusion if not isinstance(self.conclusion, set) else frozenset(self.conclusion)
+        return hash((self.user_input, conclusion_hash))
 
     def __str__(self):
         """
         Return the user string where each compare is written in a line using compare column offset start and end.
         """
-        user_input = self.parsed_user_input
+        if self.user_input is None:
+            return str(self.conclusion)
         binary_ops = sorted(self.visitor.binary_ops, key=lambda x: x.end_col_offset)
         binary_ops_indices = [b.end_col_offset for b in binary_ops]
         all_binary_ops = []
         prev_e = 0
         for i, e in enumerate(binary_ops_indices):
             if i == 0:
-                all_binary_ops.append(user_input[:e])
+                all_binary_ops.append(self.user_input[:e])
             else:
-                all_binary_ops.append(user_input[prev_e:e])
+                all_binary_ops.append(self.user_input[prev_e:e])
             prev_e = e
-        return "\n".join(all_binary_ops) if len(all_binary_ops) > 0 else user_input
+        return "\n".join(all_binary_ops) if len(all_binary_ops) > 0 else self.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(t) for t in self.conclusion_type]
+                if self.conclusion_type is not None else None,
                 "scope": {k: get_full_class_name(v) for k, v in self.scope.items()
-                          if hasattr(v, '__module__') and hasattr(v, '__name__')}
+                          if hasattr(v, '__module__') and hasattr(v, '__name__')},
+                "conclusion": conclusion_to_json(self.conclusion),
                 }
 
     @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"]),
-                   scope={k: get_type_from_string(v) for k, v in data["scope"].items()})
+        return cls(user_input=data["user_input"],
+                   conclusion_type=tuple(get_type_from_string(t) for t in data["conclusion_type"])
+                   if data["conclusion_type"] else None,
+                   scope={k: get_type_from_string(v) for k, v in data["scope"].items()},
+                   conclusion=SubclassJSONSerializer.from_json(data["conclusion"]))
 
 
 def compile_expression_to_code(expression_tree: AST) -> Any:
@@ -219,51 +206,8 @@ def compile_expression_to_code(expression_tree: AST) -> Any:
     :param expression_tree: The parsed expression tree.
     :return: The code that was compiled from the expression tree.
     """
-    return compile(expression_tree, filename="<string>", mode="eval")
-
-
-def assert_context_contains_needed_information(case: Any, context: Dict[str, Any],
-                                               visitor: VariableVisitor) -> Tuple[Set[str], Set[str]]:
-    """
-    Asserts that the variables mentioned in the expression visited by visitor are all in the given context.
-
-    :param case: The case to check the context for.
-    :param context: The context to check.
-    :param visitor: The visitor that visited the expression.
-    :return: The found variables and attributes.
-    """
-    found_variables = set()
-    for key in visitor.variables:
-        if key not in context:
-            raise ValueError(f"Variable {key} not found in the case {case}")
-        found_variables.add(key)
-
-    found_attributes = get_attributes_str(visitor)
-    for attr in found_attributes:
-        if attr not in context:
-            raise ValueError(f"Attribute {attr} not found in the case {case}")
-    return found_variables, found_attributes
-
-
-def get_attributes_str(visitor: VariableVisitor) -> Set[str]:
-    """
-    Get the string representation of the attributes in the given visitor.
-
-    :param visitor: The visitor that visited the expression.
-    :return: The string representation of the attributes.
-    """
-    found_attributes = set()
-    for key, ast_attr in visitor.attributes.items():
-        str_attr = ""
-        while isinstance(key, ast.Attribute):
-            if len(str_attr) > 0:
-                str_attr = f"{key.attr}.{str_attr}"
-            else:
-                str_attr = key.attr
-            key = key.value
-        str_attr = f"{key.id}.{str_attr}" if len(str_attr) > 0 else f"{key.id}.{ast_attr.attr}"
-        found_attributes.add(str_attr)
-    return found_attributes
+    mode = 'exec' if isinstance(expression_tree, ast.Module) else 'eval'
+    return compile(expression_tree, filename="<string>", mode=mode)
 
 
 def parse_string_to_expression(expression_str: str) -> AST:
@@ -273,6 +217,7 @@ def parse_string_to_expression(expression_str: str) -> AST:
     :param expression_str: The string which will be parsed.
     :return: The parsed expression.
     """
-    tree = ast.parse(expression_str, mode='eval')
+    mode = 'exec' if expression_str.startswith('def') else 'eval'
+    tree = ast.parse(expression_str, mode=mode)
     logging.debug(f"AST parsed successfully: {ast.dump(tree)}")
     return tree

ripple_down_rules/datastructures/case.py

@@ -24,7 +24,8 @@ class Case(UserDict, SubclassJSONSerializer):
     the names of the attributes and the values are the attributes. All are stored in lower case.
     """
 
-    def __init__(self, _obj_type: Type, _id: Optional[Hashable] = None, _name: Optional[str] = None, **kwargs):
+    def __init__(self, _obj_type: Type, _id: Optional[Hashable] = None,
+                 _name: Optional[str] = None, original_object: Optional[Any] = None, **kwargs):
         """
         Create a new row.
 
@@ -34,6 +35,7 @@ class Case(UserDict, SubclassJSONSerializer):
         :param kwargs: The attributes of the row.
         """
         super().__init__(kwargs)
+        self._original_object = original_object
         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__
@@ -63,7 +65,7 @@ class Case(UserDict, SubclassJSONSerializer):
                 new_list.extend(make_list(value))
                 super().__setitem__(name, new_list)
             else:
-                super().__setitem__(name, [self[name], value])
+                super().__setitem__(name, self[name])
         else:
             super().__setitem__(name, value)
         setattr(self, name, self[name])
@@ -221,9 +223,9 @@ def create_case(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
         return obj
     if ((recursion_idx > max_recursion_idx) or (obj.__class__.__module__ == "builtins")
             or (obj.__class__ in [MetaData, registry])):
-        return Case(type(obj), _id=id(obj), _name=obj_name,
+        return Case(type(obj), _id=id(obj), _name=obj_name, original_object=obj,
                     **{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)
+    case = Case(type(obj), _id=id(obj), _name=obj_name, original_object=obj)
     for attr in dir(obj):
         if attr.startswith("_") or callable(getattr(obj, attr)):
             continue
@@ -251,7 +253,7 @@ 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(type(obj), _id=id(obj), _name=obj_name)
+        case = Case(type(obj), _id=id(obj), _name=obj_name, original_object=obj)
     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):
@@ -280,7 +282,7 @@ def create_case_attribute_from_iterable_attribute(attr_value: Any, name: str, ob
     """
     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(_type, _id=id(attr_value), _name=name)
+    attr_case = Case(_type, _id=id(attr_value), _name=name, original_object=attr_value)
     case_attr = CaseAttribute(values)
     for idx, val in enumerate(values):
         sub_attr_case = create_case(val, recursion_idx=recursion_idx,

ripple_down_rules/datastructures/dataclasses.py

@@ -1,16 +1,15 @@
 from __future__ import annotations
 
 import inspect
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from sqlalchemy.orm import DeclarativeBase as SQLTable
-from typing_extensions import Any, Optional, Type, List, Tuple, Set, Dict, TYPE_CHECKING
+from typing_extensions import Any, Optional, Dict, Type, Tuple, Union
 
+from .callable_expression import CallableExpression
 from .case import create_case, Case
-from ..utils import get_attribute_name, copy_case, get_hint_for_attribute, typing_to_python_type
+from ..utils import copy_case, make_list, make_set
 
-if TYPE_CHECKING:
-    from . import CallableExpression
 
 @dataclass
 class CaseQuery:
@@ -19,7 +18,7 @@ class CaseQuery:
     not provided, it will be inferred from the attribute itself or from the attribute type or from the target value,
     depending on what is provided.
     """
-    case: Any
+    original_case: Any
     """
     The case that the attribute belongs to.
     """
@@ -27,64 +26,80 @@ class CaseQuery:
     """
     The name of the attribute.
     """
-    target: Optional[Any] = None
+    _attribute_types: Tuple[Type]
     """
-    The target value of the attribute.
+    The type(s) of the attribute.
     """
-    mutually_exclusive: bool = False
+    mutually_exclusive: bool
     """
     Whether the attribute can only take one value (i.e. True) or multiple values (i.e. False).
     """
-    conditions: Optional[CallableExpression] = None
+    _target: Optional[CallableExpression] = None
     """
-    The conditions that must be satisfied for the target value to be valid.
+    The target expression of the attribute.
     """
-    prediction: Optional[CallableExpression] = None
+    default_value: Optional[Any] = None
     """
-    The predicted value of the attribute.
+    The default value of the attribute. This is used when the target value is not provided.
     """
-    scope: Optional[Dict[str, Any]] = None
+    scope: Optional[Dict[str, Any]] = field(default_factory=lambda: inspect.currentframe().f_back.f_back.f_globals)
     """
     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.
     """
+    _case: Optional[Union[Case, SQLTable]] = None
+    """
+    The created case from the original case that the attribute belongs to.
+    """
+    _target_value: Optional[Any] = None
+    """
+    The target value of the case query. (This is the result of the target expression evaluation on the case.)
+    """
+    conditions: Optional[CallableExpression] = None
+    """
+    The conditions that must be satisfied for the target value to be valid.
+    """
 
-    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()
-
-        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
-
-    def _get_case(self) -> Any:
-        if not isinstance(self.original_case, (Case, SQLTable)):
-            return create_case(self.original_case, max_recursion_idx=3)
+    @property
+    def case(self) -> Any:
+        """
+        :return: The case that the attribute belongs to.
+        """
+        if self._case is not None:
+            return self._case
+        elif not isinstance(self.original_case, (Case, SQLTable)):
+            self._case = create_case(self.original_case, max_recursion_idx=3)
         else:
-            return self.original_case
+            self._case = self.original_case
+        return self._case
 
-    def _get_attribute_type(self) -> Type:
+    @case.setter
+    def case(self, value: Any):
+        """
+        Set the case that the attribute belongs to.
+        """
+        if not isinstance(value, (Case, SQLTable)):
+            raise ValueError("The case must be a Case or SQLTable object.")
+        self._case = value
+
+    @property
+    def attribute_type(self) -> Tuple[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)
+        if not self.mutually_exclusive and (set not in make_list(self._attribute_types)):
+            self._attribute_types = tuple(set(make_list(self._attribute_types) + [set, list]))
+        elif not isinstance(self._attribute_types, tuple):
+            self._attribute_types = tuple(make_list(self._attribute_types))
+        return self._attribute_types
+
+    @attribute_type.setter
+    def attribute_type(self, value: Type):
+        """
+        Set the type of the attribute.
+        """
+        self._attribute_types = tuple(make_list(value))
 
     @property
     def name(self):
@@ -100,16 +115,55 @@ class CaseQuery:
         """
         return self.case._name if isinstance(self.case, Case) else self.case.__class__.__name__
 
+    @property
+    def target(self) -> Optional[CallableExpression]:
+        """
+        :return: The target expression of the attribute.
+        """
+        if self._target is not None and not isinstance(self._target, CallableExpression):
+            self._target = CallableExpression(conclusion=self._target, conclusion_type=self.attribute_type,
+                                              scope=self.scope)
+        return self._target
+
+    @target.setter
+    def target(self, value: Optional[CallableExpression]):
+        """
+        Set the target expression of the attribute.
+        """
+        if value is not None and not isinstance(value, (CallableExpression, str)):
+            raise ValueError("The target must be a CallableExpression or a string.")
+        self._target = value
+        self._update_target_value()
+
+    @property
+    def target_value(self) -> Any:
+        """
+        :return: The target value of the case query.
+        """
+        if self._target_value is None:
+            self._update_target_value()
+        return self._target_value
+
+    def _update_target_value(self):
+        """
+        Update the target value of the case query.
+        """
+        if isinstance(self.target, CallableExpression):
+            self._target_value = self.target(self.case)
+        else:
+            self._target_value = self.target
+
     def __str__(self):
         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])
+        return "\n".join([header, target, conditions])
 
     def __repr__(self):
         return self.__str__()
 
     def __copy__(self):
-        return CaseQuery(copy_case(self.case), self.attribute_name, self.target, self.mutually_exclusive,
-                         self.conditions, self.prediction, self.scope)
+        return CaseQuery(self.original_case, self.attribute_name, self.attribute_type,
+                         self.mutually_exclusive, _target=self.target, default_value=self.default_value,
+                         scope=self.scope, _case=copy_case(self.case), _target_value=self.target_value,
+                         conditions=self.conditions)

ripple_down_rules/datastructures/enums.py

@@ -53,7 +53,7 @@ class ExpressionParser(Enum):
 
 class PromptFor(Enum):
     """
-    The reason of the prompt. (e.g. get conditions, or conclusions).
+    The reason of the prompt. (e.g. get conditions, conclusions, or affirmation).
     """
     Conditions: str = "conditions"
     """
@@ -63,6 +63,10 @@ class PromptFor(Enum):
     """
     Prompt for rule conclusion about a case.
     """
+    Affirmation: str = "affirmation"
+    """
+    Prompt for rule conclusion affirmation about a case.
+    """
 
     def __str__(self):
         return self.name