ripple-down-rules 0.6.51__py3-none-any.whl → 0.6.60__py3-none-any.whl

ripple_down_rules/predicates.py

@@ -0,0 +1,97 @@
+import os.path
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from os.path import dirname
+
+from typing_extensions import Type, ClassVar, TYPE_CHECKING, Tuple, Optional, Callable
+
+from .datastructures.tracked_object import TrackedObjectMixin, Direction, Relation
+
+if TYPE_CHECKING:
+    from .rdr_decorators import RDRDecorator
+
+
+@dataclass(eq=False)
+class Predicate(TrackedObjectMixin, ABC):
+
+    def __call__(self, *args, **kwargs):
+        return self.evaluate(*args, **kwargs)
+
+    @classmethod
+    @abstractmethod
+    def evaluate(cls, *args, **kwargs):
+        """
+        Evaluate the predicate with the given arguments.
+        This method should be implemented by subclasses.
+        """
+        pass
+
+    @classmethod
+    def rdr_decorator(cls, output_types: Tuple[Type, ...], mutually_exclusive: bool,
+                      package_name: Optional[str] = None) -> Callable[[Callable], Callable]:
+        """
+        Returns the RDRDecorator to decorate the predicate evaluate method with.
+        """
+        rdr_decorator: RDRDecorator = RDRDecorator(cls.models_dir, output_types, mutually_exclusive,
+                                                   package_name=package_name)
+        return rdr_decorator.decorator
+
+    def __hash__(self):
+        return hash(self.__class__.__name__)
+
+    def __eq__(self, other):
+        if not isinstance(other, Predicate):
+            return False
+        return self.__class__ == other.__class__
+
+
+@dataclass
+class IsA(Predicate):
+    """
+    A predicate that checks if an object type is a subclass of another object type.
+    """
+
+    @classmethod
+    def evaluate(cls, child_type: Type[TrackedObjectMixin], parent_type: Type[TrackedObjectMixin]) -> bool:
+        return issubclass(child_type, parent_type)
+
+isA = IsA()
+
+
+@dataclass
+class Has(Predicate):
+    """
+    A predicate that checks if an object type has a certain member object type.
+    """
+
+    @classmethod
+    def evaluate(cls, owner_type: Type[TrackedObjectMixin],
+                 member_type: Type[TrackedObjectMixin], recursive: bool = False) -> bool:
+        neighbors = cls._dependency_graph.adj_direction(owner_type._my_graph_idx(), Direction.OUTBOUND.value)
+        curr_val = any(e == Relation.has and isA(cls._dependency_graph.get_node_data(n), member_type)
+                       or e == Relation.isA and cls.evaluate(cls._dependency_graph.get_node_data(n), member_type)
+                       for n, e in neighbors.items())
+        if recursive:
+            return curr_val or any((e == Relation.has
+                                    and cls.evaluate(cls._dependency_graph.get_node_data(n), member_type, recursive=True))
+                                   for n, e in neighbors.items())
+        else:
+            return curr_val
+
+has = Has()
+
+
+@dataclass
+class DependsOn(Predicate):
+    """
+    A predicate that checks if an object type depends on another object type.
+    """
+
+    @classmethod
+    def evaluate(cls, dependent: Type[TrackedObjectMixin],
+                 dependency: Type[TrackedObjectMixin], recursive: bool = False) -> bool:
+        raise NotImplementedError("Should be overridden in rdr meta")
+
+
+dependsOn = DependsOn()

ripple_down_rules/rdr.py

@@ -113,7 +113,10 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         if self.save_dir is not None and self.model_name is not None:
             model_path = os.path.join(self.save_dir, self.model_name)
             if os.path.exists(model_path):
-                self.update_from_python(model_path, update_rule_tree=True)
+                try:
+                    self.update_from_python(model_path, update_rule_tree=True)
+                except (FileNotFoundError, ModuleNotFoundError) as e:
+                    pass
 
     def write_rdr_metadata_to_pyton_file(self, file: TextIOWrapper):
         """
@@ -343,11 +346,11 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                 rule.reset()
         if self.start_rule is not None and self.start_rule.parent is None:
             if self.input_node is None:
-                self.input_node = type(self.start_rule)(parent=None, uid='0')
+                self.input_node = type(self.start_rule)(_parent=None, uid='0')
                 self.input_node.evaluated = False
                 self.input_node.fired = False
             self.start_rule.parent = self.input_node
-            self.start_rule.weight = ""
+            self.start_rule.weight = RDREdge.Empty
         if self.input_node is not None:
             data = case.__dict__ if is_dataclass(case) else case
             if hasattr(case, "items"):
@@ -631,7 +634,7 @@ class TreeBuilder(ast.NodeVisitor, ABC):
         rule_uid = condition.split("conditions_")[1]
 
         new_rule_type = self.get_new_rule_type(node)
-        new_node = new_rule_type(conditions=condition, parent=self.current_parent, uid=rule_uid)
+        new_node = new_rule_type(conditions=condition, _parent=self.current_parent, uid=rule_uid)
         if self.current_parent is not None:
             self.update_current_parent(new_node)
 
@@ -1009,6 +1012,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         defs_imports = get_imports_from_types(defs_types, defs_file_name, package_name)
         corner_cases_imports = get_imports_from_types(corner_cases_types, cases_file_name, package_name)
 
+        defs_imports.append(f"from ripple_down_rules import *")
         # Add the imports to the defs file
         with open(defs_file_name, "w") as f:
             f.write('\n'.join(defs_imports) + "\n\n\n")
@@ -1068,7 +1072,7 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         main_types.update({Union, Optional})
         defs_types.add(Union)
         main_types.update({Case, create_case})
-        main_types = main_types.difference(defs_types)
+        # main_types = main_types.difference(defs_types)
         return main_types, defs_types, cases_types
 
     @property
@@ -1170,7 +1174,7 @@ class SingleClassRDR(RDRWithCodeWriter):
             self.default_conclusion = case_query.default_value
 
         pred = self.evaluate(case_query.case)
-        if pred.conclusion(case_query.case) != case_query.target_value:
+        if (not pred.fired and self.default_conclusion is None) or pred.conclusion(case_query.case) != case_query.target_value:
             expert.ask_for_conditions(case_query, pred)
             pred.fit_rule(case_query)
 

ripple_down_rules/rdr_decorators.py

@@ -3,6 +3,7 @@ This file contains decorators for the RDR (Ripple Down Rules) framework. Where e
 that can be used with any python function such that this function can benefit from the incremental knowledge acquisition
 of the RDRs.
 """
+import inspect
 import os.path
 from dataclasses import dataclass, field
 from functools import wraps
@@ -11,8 +12,9 @@ from typing import get_origin
 from typing_extensions import Callable, Optional, Type, Tuple, Dict, Any, Self, get_type_hints, List, Union, Sequence
 
 from .datastructures.case import Case
-from .datastructures.dataclasses import CaseQuery
+from .datastructures.dataclasses import CaseQuery, CaseFactoryMetaData
 from .experts import Expert, Human
+from .failures import RDRLoadError
 from .rdr import GeneralRDR
 from .utils import get_type_from_type_hint
 
@@ -21,7 +23,8 @@ try:
 except ImportError:
     RDRCaseViewer = None
 from .utils import get_method_args_as_dict, get_func_rdr_model_name, make_set, \
-    get_method_class_if_exists, str_to_snake_case, make_list
+    get_method_class_if_exists, make_list
+from .helpers import create_case_from_method
 
 
 @dataclass(unsafe_hash=True)
@@ -83,7 +86,7 @@ class RDRDecorator:
     The name of the rdr model, this gets auto generated from the function signature and the class/file it is contained
     in.
     """
-    rdr: GeneralRDR = field(init=False)
+    rdr: GeneralRDR = field(init=False, default=None)
     """
     The ripple down rules instance of the decorator class.
     """
@@ -109,12 +112,22 @@ class RDRDecorator:
     This is a flag that indicates that a not None output for the rdr has been inferred, this is used to update the 
     generated dot file if it is set to `True`.
     """
+    case_factory_metadata: CaseFactoryMetaData = field(init=False, default_factory=CaseFactoryMetaData)
+    """
+    Metadata that contains the case factory method, and the scenario that is being run during the case query.
+    """
 
     def decorator(self, func: Callable) -> Callable:
 
         @wraps(func)
         def wrapper(*args, **kwargs) -> Optional[Any]:
 
+            original_kwargs = {pname: p for pname, p in inspect.signature(func).parameters.items() if
+                               p.default != inspect._empty}
+            for og_kwarg in original_kwargs:
+                if og_kwarg not in kwargs:
+                    kwargs[og_kwarg] = original_kwargs[og_kwarg].default
+
             if self.model_name is None:
                 self.initialize_rdr_model_name_and_load(func)
             if self.origin_type is None and not self.mutual_exclusive:
@@ -124,7 +137,7 @@ class RDRDecorator:
 
             func_output = {self.output_name: func(*args, **kwargs)}
 
-            case, case_dict = self.create_case_from_method(func, func_output, *args, **kwargs)
+            case, case_dict = create_case_from_method(func, func_output, *args, **kwargs)
 
             @self.fitting_decorator
             def fit():
@@ -132,11 +145,14 @@ class RDRDecorator:
                     self.parsed_output_type = self.parse_output_type(func, self.output_type, *args)
                 if self.expert is None:
                     self.expert = Human(answers_save_path=self.models_dir + f'/{self.model_name}/expert_answers')
-                case_query = self.create_case_query_from_method(func, func_output,
-                                                                self.parsed_output_type,
-                                                                self.mutual_exclusive,
-                                                                case, case_dict,
-                                                                *args, **kwargs)
+                case_query = self.create_case_query_from_method(
+                                            func, func_output,
+                                            self.parsed_output_type,
+                                            self.mutual_exclusive,
+                                            args, kwargs,
+                                            case=case, case_dict=case_dict,
+                                            scenario=self.case_factory_metadata.scenario,
+                                            this_case_target_value=self.case_factory_metadata.this_case_target_value)
                 output = self.rdr.fit_case(case_query, expert=self.expert,
                                            update_existing_rules=self.update_existing_rules)
                 return output
@@ -166,6 +182,8 @@ class RDRDecorator:
             else:
                 return func_output[self.output_name]
 
+        wrapper._rdr_decorator_instance = self
+
         return wrapper
 
     @staticmethod
@@ -173,9 +191,11 @@ class RDRDecorator:
                                       func_output: Dict[str, Any],
                                       output_type: Sequence[Type],
                                       mutual_exclusive: bool,
+                                      func_args: Tuple[Any, ...], func_kwargs: Dict[str, Any],
                                       case: Optional[Case] = None,
                                       case_dict: Optional[Dict[str, Any]] = None,
-                                      *args, **kwargs) -> CaseQuery:
+                                      scenario: Optional[Callable] = None,
+                                      this_case_target_value: Optional[Any] = None,) -> CaseQuery:
         """
         Create a CaseQuery from the function and its arguments.
 
@@ -183,43 +203,28 @@ class RDRDecorator:
         :param func_output: The output of the function as a dictionary, where the key is the output name.
         :param output_type: The type of the output as a sequence of types.
         :param mutual_exclusive: If True, the output types are mutually exclusive.
-        :param args: The positional arguments of the function.
-        :param kwargs: The keyword arguments of the function.
+        :param func_args: The positional arguments of the function.
+        :param func_kwargs: The keyword arguments of the function.
+        :param case: The case to create.
+        :param case_dict: The dictionary of the case.
+        :param scenario: The scenario that produced the given case.
+        :param this_case_target_value: The target value for the case.
         :return: A CaseQuery object representing the case.
         """
         output_type = make_set(output_type)
         if case is None or case_dict is None:
-            case, case_dict = RDRDecorator.create_case_from_method(func, func_output, *args, **kwargs)
+            case, case_dict = create_case_from_method(func, func_output, *func_args, **func_kwargs)
         scope = func.__globals__
         scope.update(case_dict)
         func_args_type_hints = get_type_hints(func)
         output_name = list(func_output.keys())[0]
         func_args_type_hints.update({output_name: Union[tuple(output_type)]})
         return CaseQuery(case, output_name, tuple(output_type),
-                         mutual_exclusive, scope=scope,
+                         mutual_exclusive, scope=scope, scenario=scenario, this_case_target_value=this_case_target_value,
                          is_function=True, function_args_type_hints=func_args_type_hints)
 
-    @staticmethod
-    def create_case_from_method(func: Callable,
-                                func_output: Dict[str, Any],
-                                *args, **kwargs) -> Tuple[Case, Dict[str, Any]]:
-        """
-        Create a Case from the function and its arguments.
-
-        :param func: The function to create a case from.
-        :param func_output: A dictionary containing the output of the function, where the key is the output name.
-        :param args: The positional arguments of the function.
-        :param kwargs: The keyword arguments of the function.
-        :return: A Case object representing the case.
-        """
-        case_dict = get_method_args_as_dict(func, *args, **kwargs)
-        case_dict.update(func_output)
-        case_name = get_func_rdr_model_name(func)
-        return Case(dict, id(case_dict), case_name, case_dict, **case_dict), case_dict
-
     def initialize_rdr_model_name_and_load(self, func: Callable) -> None:
-        model_file_name = get_func_rdr_model_name(func, include_file_name=True)
-        self.model_name = str_to_snake_case(model_file_name)
+        self.model_name = get_func_rdr_model_name(func, include_file_name=True)
         self.load()
 
     @staticmethod
@@ -242,3 +247,8 @@ class RDRDecorator:
         Load the RDR model from the specified directory, otherwise create a new one.
         """
         self.rdr = GeneralRDR(save_dir=self.models_dir, model_name=self.model_name)
+
+
+def fit_rdr_func(scenario: Callable, rdr_decorated_func: Callable, *func_args, **func_kwargs) -> None:
+    rdr_decorated_func._rdr_decorator_instance.case_factory_metadata = CaseFactoryMetaData(scenario=scenario)
+    rdr_decorated_func(*func_args, **func_kwargs)