ripple-down-rules 0.1.3__tar.gz → 0.1.6__tar.gz

{ripple_down_rules-0.1.3 → ripple_down_rules-0.1.6}/PKG-INFO

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

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.3"
+version = "0.1.6"
 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.1.3 → ripple_down_rules-0.1.6}/src/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-0.1.6/src/ripple_down_rules/datastructures/__init__.py

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

{ripple_down_rules-0.1.3 → ripple_down_rules-0.1.6}/src/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):
@@ -89,93 +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 output is None:
-                output = scope['_get_value'](case)
-            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}")
 
@@ -184,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:
@@ -226,50 +210,6 @@ def compile_expression_to_code(expression_tree: AST) -> Any:
     return compile(expression_tree, filename="<string>", mode=mode)
 
 
-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
-
-
 def parse_string_to_expression(expression_str: str) -> AST:
     """
     Parse a string statement into an AST expression.

{ripple_down_rules-0.1.3 → ripple_down_rules-0.1.6}/src/ripple_down_rules/datastructures/case.py

@@ -63,7 +63,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])

ripple_down_rules-0.1.6/src/ripple_down_rules/datastructures/dataclasses.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import inspect
+from dataclasses import dataclass, field
+
+from sqlalchemy.orm import DeclarativeBase as SQLTable
+from typing_extensions import Any, Optional, Dict, Type, Tuple, Union
+
+from .callable_expression import CallableExpression
+from .case import create_case, Case
+from ..utils import copy_case, make_list
+
+
+@dataclass
+class CaseQuery:
+    """
+    This is a dataclass that represents an attribute of an object and its target value. If attribute name is
+    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.
+    """
+    original_case: Any
+    """
+    The case that the attribute belongs to.
+    """
+    attribute_name: str
+    """
+    The name of the attribute.
+    """
+    _attribute_types: Tuple[Type]
+    """
+    The type(s) of the attribute.
+    """
+    mutually_exclusive: bool
+    """
+    Whether the attribute can only take one value (i.e. True) or multiple values (i.e. False).
+    """
+    _target: Optional[CallableExpression] = None
+    """
+    The target expression of the attribute.
+    """
+    default_value: Optional[Any] = None
+    """
+    The default value of the attribute. This is used when the target value is not provided.
+    """
+    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.
+    """
+
+    @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:
+            self._case = self.original_case
+        return self._case
+
+    @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.
+        """
+        self._attribute_types = tuple(make_list(self._attribute_types))
+        if not self.mutually_exclusive and (set not in self._attribute_types):
+            self._attribute_types = tuple(list(self._attribute_types) + [set])
+        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):
+        """
+        :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__
+
+    @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 '?'}"
+        conditions = f"Conditions: {self.conditions if self.conditions is not None else '?'}"
+        return "\n".join([header, target, conditions])
+
+    def __repr__(self):
+        return self.__str__()
+
+    def __copy__(self):
+        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-0.1.3 → ripple_down_rules-0.1.6}/src/ripple_down_rules/experts.py

@@ -3,13 +3,15 @@ from __future__ import annotations
 import json
 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, get_type_hints
+from typing_extensions import Optional, Dict, TYPE_CHECKING, List, Type, Any
 
-from .datastructures import (Case, PromptFor, CallableExpression, CaseAttribute, CaseQuery)
+from .datastructures.case import Case, CaseAttribute
+from .datastructures.callable_expression import CallableExpression
+from .datastructures.enums import PromptFor
+from .datastructures.dataclasses import 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
+from .prompt import prompt_user_for_expression
+from .utils import get_all_subclasses, make_list
 
 if TYPE_CHECKING:
     from .rdr import Rule
@@ -89,10 +91,9 @@ class Human(Expert):
     The Human Expert class, an expert that asks the human to provide differentiating features and conclusions.
     """
 
-    def __init__(self, use_loaded_answers: bool = False, session: Optional[Session] = None):
+    def __init__(self, use_loaded_answers: bool = False):
         self.all_expert_answers = []
         self.use_loaded_answers = use_loaded_answers
-        self.session = session
 
     def save_answers(self, path: str, append: bool = False):
         """
@@ -142,9 +143,9 @@ class Human(Expert):
         if self.use_loaded_answers:
             user_input = self.all_expert_answers.pop(0)
         if user_input:
-            condition = CallableExpression(user_input, bool, scope=case_query.scope, session=self.session)
+            condition = CallableExpression(user_input, bool, scope=case_query.scope)
         else:
-            user_input, condition = prompt_user_for_expression(case_query, PromptFor.Conditions, session=self.session)
+            user_input, condition = prompt_user_for_expression(case_query, PromptFor.Conditions)
         if not self.use_loaded_answers:
             self.all_expert_answers.append(user_input)
         case_query.conditions = condition
@@ -168,21 +169,22 @@ class Human(Expert):
             extra_conclusions[category] = self._get_conditions(case, {category.__class__.__name__: category})
         return extra_conclusions
 
-    def ask_for_conclusion(self, case_query: CaseQuery) -> CaseQuery:
+    def ask_for_conclusion(self, case_query: CaseQuery) -> Optional[CallableExpression]:
         """
         Ask the expert to provide a conclusion for the case.
 
         :param case_query: The case query containing the case to find a conclusion for.
-        :return: The case query updated with the conclusion for the case.
+        :return: The conclusion for the case as a callable expression.
         """
+        expression: Optional[CallableExpression] = None
         if self.use_loaded_answers:
             expert_input = self.all_expert_answers.pop(0)
-            expression = CallableExpression(expert_input, case_query.attribute_type, session=self.session,
-                                            scope=case_query.scope)
+            if expert_input is not None:
+                expression = CallableExpression(expert_input, case_query.attribute_type,
+                                                scope=case_query.scope)
         else:
             show_current_and_corner_cases(case_query.case)
-            expert_input, expression = prompt_user_for_expression(case_query, PromptFor.Conclusion,
-                                                                  session=self.session)
+            expert_input, expression = prompt_user_for_expression(case_query, PromptFor.Conclusion)
             self.all_expert_answers.append(expert_input)
         case_query.target = expression
         return expression
@@ -195,7 +197,8 @@ class Human(Expert):
         :return: The category type.
         """
         cat_name = cat_name.lower()
-        self.known_categories = get_all_subclasses(CaseAttribute) if not self.known_categories else self.known_categories
+        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:
@@ -211,9 +214,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: CaseAttribute,
-                                     targets: Optional[List[CaseAttribute]] = None,
-                                     current_conclusions: Optional[List[CaseAttribute]] = None) -> bool:
+    def ask_if_conclusion_is_correct(self, x: Case, conclusion: Any,
+                                     targets: Optional[List[Any]] = None,
+                                     current_conclusions: Optional[List[Any]] = None) -> bool:
         """
         Ask the expert if the conclusion is correct.
 
@@ -225,9 +228,8 @@ class Human(Expert):
         question = ""
         if not self.use_loaded_answers:
             targets = targets or []
-            targets = targets if isinstance(targets, list) else [targets]
-            x.conclusions = current_conclusions
-            x.targets = targets
+            x.conclusions = make_list(current_conclusions)
+            x.targets = make_list(targets)
             question = f"Is the conclusion {conclusion} correct for the case (y/n):" \
                        f"\n{str(x)}"
         return self.ask_yes_no_question(question)