ripple-down-rules 0.1.21__tar.gz → 0.1.62__tar.gz

{ripple_down_rules-0.1.21 → ripple_down_rules-0.1.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.21
+Version: 0.1.62
 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
@@ -709,7 +709,7 @@ Fit the SCRDR to the data, then classify one of the data cases to check if its c
 and render the tree to a file:
 
 ```Python
-from ripple_down_rules.datastructures import CaseQuery
+from ripple_down_rules.datastructures.dataclasses import CaseQuery
 from ripple_down_rules.rdr import SingleClassRDR
 from ripple_down_rules.datasets import load_zoo_dataset
 from ripple_down_rules.utils import render_tree
@@ -719,12 +719,13 @@ all_cases, targets = load_zoo_dataset()
 scrdr = SingleClassRDR()
 
 # Fit the SCRDR to the data
-case_queries = [CaseQuery(case, target=target) for case, target in zip(all_cases, targets)]
+case_queries = [CaseQuery(case, 'species', type(target), True, _target=target)
+                for case, target in zip(all_cases[:10], targets[:10])]
 scrdr.fit(case_queries, animate_tree=True)
 
 # Render the tree to a file
 render_tree(scrdr.start_rule, use_dot_exporter=True, filename="scrdr")
 
-cat = scrdr.fit_case(all_cases[50], targets[50])
+cat = scrdr.classify(all_cases[50])
 assert cat == targets[50]
 ```

{ripple_down_rules-0.1.21 → ripple_down_rules-0.1.62}/README.md

@@ -22,7 +22,7 @@ Fit the SCRDR to the data, then classify one of the data cases to check if its c
 and render the tree to a file:
 
 ```Python
-from ripple_down_rules.datastructures import CaseQuery
+from ripple_down_rules.datastructures.dataclasses import CaseQuery
 from ripple_down_rules.rdr import SingleClassRDR
 from ripple_down_rules.datasets import load_zoo_dataset
 from ripple_down_rules.utils import render_tree
@@ -32,12 +32,13 @@ all_cases, targets = load_zoo_dataset()
 scrdr = SingleClassRDR()
 
 # Fit the SCRDR to the data
-case_queries = [CaseQuery(case, target=target) for case, target in zip(all_cases, targets)]
+case_queries = [CaseQuery(case, 'species', type(target), True, _target=target)
+                for case, target in zip(all_cases[:10], targets[:10])]
 scrdr.fit(case_queries, animate_tree=True)
 
 # Render the tree to a file
 render_tree(scrdr.start_rule, use_dot_exporter=True, filename="scrdr")
 
-cat = scrdr.fit_case(all_cases[50], targets[50])
+cat = scrdr.classify(all_cases[50])
 assert cat == targets[50]
 ```

{ripple_down_rules-0.1.21 → ripple_down_rules-0.1.62}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.21"
+version = "0.1.62"
 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.21 → ripple_down_rules-0.1.62}/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.62/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.62/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.21 → ripple_down_rules-0.1.62}/src/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-0.1.62/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, make_list, make_set
+
+
+@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 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):
+        """
+        :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.21 → ripple_down_rules-0.1.62}/src/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