ripple-down-rules 0.1.2__tar.gz → 0.1.5__tar.gz

{ripple_down_rules-0.1.2 → ripple_down_rules-0.1.5}/PKG-INFO

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

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.2"
+version = "0.1.5"
 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.2 → ripple_down_rules-0.1.5}/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.5/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.5/src/ripple_down_rules/datastructures/callable_expression.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+import ast
+import logging
+from _ast import AST
+
+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, conclusion_to_json, is_iterable
+
+
+class VariableVisitor(ast.NodeVisitor):
+    """
+    A visitor to extract all variables and comparisons from a python expression represented as an AST tree.
+    """
+    compares: List[Tuple[Union[ast.Name, ast.Call], ast.cmpop, Union[ast.Name, ast.Call]]]
+    variables: Set[str]
+    all: List[ast.BoolOp]
+
+    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
+        self.generic_visit(node)
+
+    def visit_BinOp(self, node):
+        self.binary_ops.append(node)
+        self.all.append(node)
+        self.generic_visit(node)
+
+    def visit_BoolOp(self, node):
+        self.all.append(node)
+        self.generic_visit(node)
+
+    def visit_Compare(self, node):
+        self.all.append(node)
+        self.compares.append([node.left, node.ops[0], node.comparators[0]])
+        self.generic_visit(node)
+
+    def visit_Name(self, node):
+        if f"__{node.id}__" not in dir(__builtins__) and node not in self.attributes:
+            self.variables.add(node.id)
+        self.generic_visit(node)
+
+
+def get_used_scope(code_str, scope):
+    # Parse the code into an AST
+    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):
+        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.
+    """
+
+    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 scope: The scope to use for the callable expression.
+        :param conclusion: The conclusion to use for the callable expression.
+        """
+        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
+        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 {}
+        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 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}")
+
+    def combine_with(self, other: 'CallableExpression') -> 'CallableExpression':
+        """
+        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)
+
+    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.
+        """
+        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(self.user_input[:e])
+            else:
+                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 self.user_input
+
+    def _to_json(self) -> Dict[str, Any]:
+        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__')},
+                "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=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:
+    """
+    Compile an expression tree that was parsed from string into code that can be executed using 'eval(code)'
+
+    :param expression_tree: The parsed expression tree.
+    :return: The code that was compiled from the expression tree.
+    """
+    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:
+    """
+    Parse a string statement into an AST expression.
+
+    :param expression_str: The string which will be parsed.
+    :return: The parsed expression.
+    """
+    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-0.1.2 → ripple_down_rules-0.1.5}/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.5/src/ripple_down_rules/datastructures/dataclasses.py

@@ -0,0 +1,169 @@
+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
+
+
+@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.
+        """
+        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.
+        """
+        if not isinstance(value, tuple):
+            value = (value,)
+        self._attribute_types = 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.2 → ripple_down_rules-0.1.5}/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)