ripple-down-rules 0.2.3__tar.gz → 0.3.0__tar.gz

{ripple_down_rules-0.2.3 → ripple_down_rules-0.3.0}/PKG-INFO

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

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.2.3"
+version = "0.3.0"
 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.2.3 → ripple_down_rules-0.3.0}/src/ripple_down_rules/datasets.py

@@ -2,15 +2,17 @@ from __future__ import annotations
 
 import os
 import pickle
+from dataclasses import dataclass, field
 
 import sqlalchemy
 from sqlalchemy import ForeignKey
-from sqlalchemy.orm import MappedAsDataclass, Mapped, mapped_column, relationship
-from typing_extensions import Tuple, List, Set, Optional
+from sqlalchemy.orm import MappedAsDataclass, Mapped, mapped_column, relationship, MappedColumn
+from typing_extensions import Tuple, List, Set, Optional, Self
 from ucimlrepo import fetch_ucirepo
 
 from .datastructures.case import Case, create_cases_from_dataframe
 from .datastructures.enums import Category
+from .rdr_decorators import RDRDecorator
 
 
 def load_cached_dataset(cache_file):
@@ -106,8 +108,65 @@ class Habitat(Category):
     air = "air"
 
 
-# SpeciesCol = Column.create_from_enum(Species, mutually_exclusive=True)
-# HabitatCol = Column.create_from_enum(Habitat, mutually_exclusive=False)
+class PhysicalObject:
+    """
+    A physical object is an object that can be contained in a container.
+    """
+    _rdr_json_dir: str = os.path.join(os.path.dirname(__file__), "../../test/test_results")
+    """
+    The directory where the RDR serialized JSON files are stored.
+    """
+    _rdr_python_dir: str = os.path.join(os.path.dirname(__file__), "../../test/test_generated_rdrs")
+    """
+    The directory where the RDR generated Python files are stored.
+    """
+    _is_a_robot_rdr: RDRDecorator = RDRDecorator(_rdr_json_dir, (bool,), True,
+                                                 python_dir=_rdr_python_dir)
+    """
+    The RDR decorator that is used to determine if the object is a robot or not.
+    """
+    _select_parts_rdr: RDRDecorator = RDRDecorator(_rdr_json_dir, (Self,), False,
+                                                   python_dir=_rdr_python_dir)
+    """
+    The RDR decorator that is used to determine if the object is a robot or not.
+    """
+
+    def __init__(self, name: str, contained_objects: Optional[List[PhysicalObject]] = None):
+        self.name: str = name
+        self._contained_objects: List[PhysicalObject] = contained_objects or []
+
+    @property
+    def contained_objects(self) -> List[PhysicalObject]:
+        return self._contained_objects
+
+    @contained_objects.setter
+    def contained_objects(self, value: List[PhysicalObject]):
+        self._contained_objects = value
+
+    @_is_a_robot_rdr.decorator
+    def is_a_robot(self) -> bool:
+        pass
+
+    @_select_parts_rdr.decorator
+    def select_objects_that_are_parts_of_robot(self, objects: List[PhysicalObject], robot: Robot) -> List[PhysicalObject]:
+        pass
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.name
+
+
+class Part(PhysicalObject):
+    ...
+
+
+class Robot(PhysicalObject):
+
+    def __init__(self, name: str, parts: Optional[List[Part]] = None):
+        super().__init__(name)
+        self.parts: List[Part] = parts if parts else []
 
 
 class Base(sqlalchemy.orm.DeclarativeBase):
@@ -119,7 +178,7 @@ class HabitatTable(MappedAsDataclass, Base):
 
     id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)
     habitat: Mapped[Habitat]
-    animal_id = mapped_column(ForeignKey("Animal.id"), init=False)
+    animal_id: MappedColumn = mapped_column(ForeignKey("Animal.id"), init=False)
 
     def __hash__(self):
         return hash(self.habitat)
@@ -131,7 +190,7 @@ class HabitatTable(MappedAsDataclass, Base):
         return self.__str__()
 
 
-class Animal(MappedAsDataclass, Base):
+class MappedAnimal(MappedAsDataclass, Base):
     __tablename__ = "Animal"
 
     id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)
@@ -155,3 +214,4 @@ class Animal(MappedAsDataclass, Base):
     species: Mapped[Species] = mapped_column(nullable=True)
 
     habitats: Mapped[Set[HabitatTable]] = relationship(default_factory=set)
+

{ripple_down_rules-0.2.3 → ripple_down_rules-0.3.0}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -93,9 +93,12 @@ class CallableExpression(SubclassJSONSerializer):
     """
     encapsulating_function: str = "def _get_value(case):"
 
-    def __init__(self, user_input: Optional[str] = None, conclusion_type: Optional[Tuple[Type]] = 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):
+                 scope: Optional[Dict[str, Any]] = None,
+                 conclusion: Optional[Any] = None,
+                 mutually_exclusive: bool = True):
         """
         Create a callable expression.
 
@@ -104,6 +107,8 @@ class CallableExpression(SubclassJSONSerializer):
         :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.
+        :param mutually_exclusive: If True, the conclusion is mutually exclusive, i.e. the callable expression can only
+            return one conclusion. If False, the callable expression can return multiple conclusions.
         """
         if user_input is None and conclusion is None:
             raise ValueError("Either user_input or conclusion must be provided.")
@@ -123,6 +128,7 @@ class CallableExpression(SubclassJSONSerializer):
         self.code = compile_expression_to_code(self.expression_tree)
         self.visitor = VariableVisitor()
         self.visitor.visit(self.expression_tree)
+        self.mutually_exclusive: bool = mutually_exclusive
 
     def __call__(self, case: Any, **kwargs) -> Any:
         try:
@@ -134,6 +140,8 @@ class CallableExpression(SubclassJSONSerializer):
                 if output is None:
                     output = scope['_get_value'](case)
                 if self.conclusion_type is not None:
+                    if self.mutually_exclusive and issubclass(type(output), (list, set)):
+                        raise ValueError(f"Mutually exclusive types cannot be lists or sets, got {type(output)}")
                     output_types = {type(o) for o in make_list(output)}
                     output_types.add(type(output))
                     if not are_results_subclass_of_types(output_types, self.conclusion_type):
@@ -227,6 +235,7 @@ class CallableExpression(SubclassJSONSerializer):
                 "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),
+                "mutually_exclusive": self.mutually_exclusive,
                 }
 
     @classmethod
@@ -235,7 +244,8 @@ class CallableExpression(SubclassJSONSerializer):
                    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"]))
+                   conclusion=SubclassJSONSerializer.from_json(data["conclusion"]),
+                   mutually_exclusive=data["mutually_exclusive"])
 
 
 def compile_expression_to_code(expression_tree: AST) -> Any:

{ripple_down_rules-0.2.3 → ripple_down_rules-0.3.0}/src/ripple_down_rules/datastructures/case.py

@@ -11,7 +11,7 @@ from sqlalchemy.orm import DeclarativeBase as SQLTable, MappedColumn as SQLColum
 from typing_extensions import Any, Optional, Dict, Type, Set, Hashable, Union, List, TYPE_CHECKING
 
 from ..utils import make_set, row_to_dict, table_rows_as_str, get_value_type_from_type_hint, SubclassJSONSerializer, \
-    get_full_class_name, get_type_from_string, make_list, is_iterable, serialize_dataclass, dataclass_to_dict
+    get_full_class_name, get_type_from_string, make_list, is_iterable, serialize_dataclass, dataclass_to_dict, copy_case
 
 if TYPE_CHECKING:
     from ripple_down_rules.rules import Rule
@@ -65,7 +65,7 @@ class Case(UserDict, SubclassJSONSerializer):
                 new_list.extend(make_list(value))
                 super().__setitem__(name, new_list)
             else:
-                super().__setitem__(name, self[name])
+                super().__setitem__(name, value)
         else:
             super().__setitem__(name, value)
         setattr(self, name, self[name])
@@ -102,6 +102,29 @@ class Case(UserDict, SubclassJSONSerializer):
             data[k] = SubclassJSONSerializer.from_json(v)
         return cls(_obj_type=obj_type, _id=id_, _name=name, **data)
 
+    def __deepcopy__(self, memo: Dict[Hashable, Any]) -> Case:
+        """
+        Create a deep copy of the case.
+
+        :param memo: A dictionary to keep track of objects that have already been copied.
+        :return: A deep copy of the case.
+        """
+        new_case = Case(self._obj_type, _id=self._id, _name=self._name, original_object=self._original_object)
+        for k, v in self.items():
+            new_case[k] = deepcopy(v)
+        return new_case
+
+    def __copy__(self) -> Case:
+        """
+        Create a shallow copy of the case.
+
+        :return: A shallow copy of the case.
+        """
+        new_case = Case(self._obj_type, _id=self._id, _name=self._name, original_object=self._original_object)
+        for k, v in self.items():
+            new_case[k] = copy(v)
+        return new_case
+
 
 @dataclass
 class CaseAttributeValue(SubclassJSONSerializer):
@@ -220,11 +243,16 @@ def create_case(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
         return create_cases_from_dataframe(obj, obj_name)
     if isinstance(obj, Case) or (is_dataclass(obj) and not isinstance(obj, SQLTable)):
         return obj
-    if ((recursion_idx > max_recursion_idx) or (obj.__class__.__module__ == "builtins")
+    if ((recursion_idx > max_recursion_idx)
+            or (obj.__class__.__module__ == "builtins" and not isinstance(obj, (list, set, dict)))
             or (obj.__class__ in [MetaData, registry])):
         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, original_object=obj)
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            case = create_or_update_case_from_attribute(v, k, obj, obj_name, recursion_idx,
+                                                        max_recursion_idx, parent_is_iterable, case)
     for attr in dir(obj):
         if attr.startswith("_") or callable(getattr(obj, attr)):
             continue
@@ -322,9 +350,9 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] =
         if last_evaluated_rule and last_evaluated_rule.fired:
             corner_row_dict = dataclass_to_dict(last_evaluated_rule.corner_case)
     else:
-        case_dict = case
+        case_dict = copy_case(case)
         if last_evaluated_rule and last_evaluated_rule.fired:
-            corner_row_dict = corner_case
+            corner_row_dict = copy_case(corner_case)
 
     if corner_row_dict:
         corner_conclusion = last_evaluated_rule.conclusion(case)

{ripple_down_rules-0.2.3 → ripple_down_rules-0.3.0}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -1,14 +1,17 @@
 from __future__ import annotations
 
 import inspect
+import typing
 from dataclasses import dataclass, field
 
+import typing_extensions
 from sqlalchemy.orm import DeclarativeBase as SQLTable
-from typing_extensions import Any, Optional, Dict, Type, Tuple, Union
+from typing_extensions import Any, Optional, Dict, Type, Tuple, Union, List, get_origin, Set
 
 from .callable_expression import CallableExpression
 from .case import create_case, Case
-from ..utils import copy_case, make_list, make_set
+from ..utils import copy_case, make_list, make_set, get_origin_and_args_from_type_hint, get_value_type_from_type_hint, \
+    typing_to_python_type
 
 
 @dataclass
@@ -60,6 +63,22 @@ class CaseQuery:
     """
     The conditions that must be satisfied for the target value to be valid.
     """
+    is_function: bool = False
+    """
+    Whether the case is a dict representing the arguments of an actual function or not,
+    most likely means it came from RDRDecorator, the the rdr takes function arguments and outputs the function output.
+    """
+    function_args_type_hints: Optional[Dict[str, Type]] = None
+    """
+    The type hints of the function arguments. This is used to recreate the function signature.
+    """
+
+    @property
+    def case_type(self) -> Type:
+        """
+        :return: The type of the case that the attribute belongs to.
+        """
+        return self.original_case._obj_type if isinstance(self.original_case, Case) else type(self.original_case)
 
     @property
     def case(self) -> Any:
@@ -83,22 +102,46 @@ class CaseQuery:
             raise ValueError("The case must be a Case or SQLTable object.")
         self._case = value
 
+    @property
+    def attribute_type_hint(self) -> str:
+        """
+        :return: The type hint of the attribute as a typing object.
+        """
+        if len(self.core_attribute_type) > 1:
+            attribute_types_str = f"Union[{', '.join([t.__name__ for t in self.core_attribute_type])}]"
+        else:
+            attribute_types_str = self.core_attribute_type[0].__name__
+        if list in self.attribute_type:
+            return f"List[{attribute_types_str}]"
+        else:
+            return attribute_types_str
+
     @property
     def core_attribute_type(self) -> Tuple[Type]:
         """
         :return: The core type of the attribute.
         """
-        return (t for t in self.attribute_type if t not in (set, list))
+        return tuple(t for t in self.attribute_type if t not in (set, list))
 
     @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))
+        if not isinstance(self._attribute_types, tuple):
+            self._attribute_types = tuple(make_set(self._attribute_types))
+        origin, args = get_origin_and_args_from_type_hint(self._attribute_types)
+        if origin is not None:
+            att_types = make_set(origin)
+            if origin in (list, set, tuple, List, Set, Union, Tuple):
+                att_types.update(make_set(args))
+            elif origin in (dict, Dict):
+                # ignore the key type
+                if args and len(args) > 1:
+                    att_types.update(make_set(args[1]))
+            self._attribute_types = tuple(att_types)
+        if not self.mutually_exclusive and (list not in self._attribute_types):
+            self._attribute_types = tuple(make_list(self._attribute_types) + [set, list])
         return self._attribute_types
 
     @attribute_type.setter
@@ -129,7 +172,7 @@ class CaseQuery:
         """
         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)
+                                              scope=self.scope, mutually_exclusive=self.mutually_exclusive)
         return self._target
 
     @target.setter
@@ -173,4 +216,5 @@ class CaseQuery:
         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)
+                         conditions=self.conditions, is_function=self.is_function,
+                         function_args_type_hints=self.function_args_type_hints)

{ripple_down_rules-0.2.3 → ripple_down_rules-0.3.0}/src/ripple_down_rules/datastructures/enums.py

@@ -2,11 +2,40 @@ from __future__ import annotations
 
 from enum import auto, Enum
 
-from typing_extensions import List, Dict, Any
+from typing_extensions import List, Dict, Any, Type
 
 from ripple_down_rules.utils import SubclassJSONSerializer
 
 
+class Editor(str, Enum):
+    """
+    The editor that is used to edit the rules.
+    """
+    Pycharm = "pycharm"
+    """
+    PyCharm editor.
+    """
+    Code = "code"
+    """
+    Visual Studio Code editor.
+    """
+    CodeServer = "code-server"
+    """
+    Visual Studio Code server editor.
+    """
+    @classmethod
+    def from_str(cls, editor: str) -> Editor:
+        """
+        Convert a string value to an Editor enum.
+
+        :param editor: The string that represents the editor name.
+        :return: The Editor enum.
+        """
+        if editor not in cls._value2member_map_:
+            raise ValueError(f"Editor {editor} is not supported.")
+        return cls._value2member_map_[editor]
+
+
 class Category(str, SubclassJSONSerializer, Enum):
 
     @classmethod

{ripple_down_rules-0.2.3 → ripple_down_rules-0.3.0}/src/ripple_down_rules/experts.py

@@ -138,7 +138,8 @@ class Human(Expert):
             expert_input = self.all_expert_answers.pop(0)
             if expert_input is not None:
                 expression = CallableExpression(expert_input, case_query.attribute_type,
-                                                scope=case_query.scope)
+                                                scope=case_query.scope,
+                                                 mutually_exclusive=case_query.mutually_exclusive)
         else:
             show_current_and_corner_cases(case_query.case)
             expert_input, expression = prompt_user_for_expression(case_query, PromptFor.Conclusion)