ripple-down-rules 0.5.5__py3-none-any.whl → 0.5.8__py3-none-any.whl

ripple_down_rules/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.5.5"
+__version__ = "0.5.8"
 
 import logging
 logger = logging.Logger("rdr")

ripple_down_rules/datastructures/callable_expression.py

@@ -93,7 +93,6 @@ class CallableExpression(SubclassJSONSerializer):
     A callable that is constructed from a string statement written by an expert.
     """
     encapsulating_function_name: str = "_get_value"
-    encapsulating_function: str = f"def {encapsulating_function_name}(case):"
 
     def __init__(self, user_input: Optional[str] = None,
                  conclusion_type: Optional[Tuple[Type]] = None,
@@ -117,7 +116,7 @@ class CallableExpression(SubclassJSONSerializer):
         if user_input is None:
             user_input = build_user_input_from_conclusion(conclusion)
         self.conclusion: Optional[Any] = conclusion
-        self._user_input: str = encapsulate_user_input(user_input, self.encapsulating_function)
+        self._user_input: str = encapsulate_user_input(user_input, self.get_encapsulating_function())
         if conclusion_type is not None:
             if is_iterable(conclusion_type):
                 conclusion_type = tuple(conclusion_type)
@@ -132,6 +131,13 @@ class CallableExpression(SubclassJSONSerializer):
         self.visitor.visit(self.expression_tree)
         self.mutually_exclusive: bool = mutually_exclusive
 
+    @classmethod
+    def get_encapsulating_function(cls, postfix: str = '') -> str:
+        """
+        Get the encapsulating function that is used to wrap the user input.
+        """
+        return f"def {cls.encapsulating_function_name}{postfix}(case):"
+
     def __call__(self, case: Any, **kwargs) -> Any:
         try:
             if self.user_input is not None:
@@ -161,8 +167,8 @@ class CallableExpression(SubclassJSONSerializer):
         """
         Combine this callable expression with another callable expression using the 'and' operator.
         """
-        cond1_user_input = self.user_input.replace(self.encapsulating_function, "def _cond1(case):")
-        cond2_user_input = other.user_input.replace(self.encapsulating_function, "def _cond2(case):")
+        cond1_user_input = self.user_input.replace(self.get_encapsulating_function(), "def _cond1(case):")
+        cond2_user_input = other.user_input.replace(self.get_encapsulating_function(), "def _cond2(case):")
         new_user_input = (f"{cond1_user_input}\n"
                           f"{cond2_user_input}\n"
                           f"return _cond1(case) and _cond2(case)")
@@ -175,7 +181,7 @@ class CallableExpression(SubclassJSONSerializer):
         new_function_body = extract_function_source(file_path, [function_name])[function_name]
         if new_function_body is None:
             return
-        self.user_input = self.encapsulating_function + '\n' + new_function_body
+        self.user_input = self.get_encapsulating_function() + '\n' + new_function_body
 
     def write_to_python_file(self, file_path: str, append: bool = False):
         """
@@ -208,7 +214,7 @@ class CallableExpression(SubclassJSONSerializer):
         Set the user input.
         """
         if value is not None:
-            self._user_input = encapsulate_user_input(value, self.encapsulating_function)
+            self._user_input = encapsulate_user_input(value, self.get_encapsulating_function())
             self.scope = get_used_scope(self.user_input, self.scope)
             self.expression_tree = parse_string_to_expression(self.user_input)
             self.code = compile_expression_to_code(self.expression_tree)
@@ -253,7 +259,8 @@ class CallableExpression(SubclassJSONSerializer):
                 "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__')
+                          and v.__module__ is not None and v.__name__ is not None},
                 "conclusion": conclusion_to_json(self.conclusion),
                 "mutually_exclusive": self.mutually_exclusive,
                 }
@@ -286,8 +293,8 @@ def parse_string_to_expression(expression_str: str) -> AST:
     :param expression_str: The string which will be parsed.
     :return: The parsed expression.
     """
-    if not expression_str.startswith(CallableExpression.encapsulating_function):
-        expression_str = encapsulate_user_input(expression_str, CallableExpression.encapsulating_function)
+    if not expression_str.startswith(CallableExpression.get_encapsulating_function()):
+        expression_str = encapsulate_user_input(expression_str, CallableExpression.get_encapsulating_function())
     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)}")

ripple_down_rules/datastructures/case.py

@@ -84,7 +84,7 @@ class Case(UserDict, SubclassJSONSerializer):
     def _to_json(self) -> Dict[str, Any]:
         serializable = {k: v for k, v in self.items() if not k.startswith("_")}
         serializable["_id"] = self._id
-        serializable["_obj_type"] = get_full_class_name(self._obj_type)
+        serializable["_obj_type"] = get_full_class_name(self._obj_type) if self._obj_type is not None else None
         serializable["_name"] = self._name
         for k, v in serializable.items():
             if isinstance(v, set):
@@ -96,7 +96,7 @@ class Case(UserDict, SubclassJSONSerializer):
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Case:
         id_ = data.pop("_id")
-        obj_type = get_type_from_string(data.pop("_obj_type"))
+        obj_type = get_type_from_string(data.pop("_obj_type")) if data["_obj_type"] is not None else None
         name = data.pop("_name")
         for k, v in data.items():
             data[k] = SubclassJSONSerializer.from_json(v)
@@ -308,7 +308,10 @@ def create_case_attribute_from_iterable_attribute(attr_value: Any, name: str, ob
     :return: A case attribute that represents the original iterable attribute.
     """
     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)
+    try:
+        _type = type(list(values)[0]) if len(values) > 0 else get_value_type_from_type_hint(name, obj)
+    except ValueError:
+        _type = None
     attr_case = Case(_type, _id=id(attr_value), _name=name, original_object=attr_value)
     case_attr = CaseAttribute(values)
     for idx, val in enumerate(values):
@@ -317,7 +320,10 @@ def create_case_attribute_from_iterable_attribute(attr_value: Any, name: str, ob
                                     obj_name=name, parent_is_iterable=True)
         attr_case.update(sub_attr_case)
     for sub_attr, val in attr_case.items():
-        setattr(case_attr, sub_attr, val)
+        try:
+            setattr(case_attr, sub_attr, val)
+        except AttributeError:
+            pass
     return case_attr
 
 

ripple_down_rules/datastructures/dataclasses.py

@@ -5,9 +5,11 @@ import typing
 from dataclasses import dataclass, field
 
 import typing_extensions
+from omegaconf import MISSING
 from sqlalchemy.orm import DeclarativeBase as SQLTable
-from typing_extensions import Any, Optional, Dict, Type, Tuple, Union, List, get_origin, Set
+from typing_extensions import Any, Optional, Dict, Type, Tuple, Union, List, get_origin, Set, Callable
 
+from ..utils import get_method_name, get_function_import_data, get_function_representation
 from .callable_expression import CallableExpression
 from .case import create_case, Case
 from ..utils import copy_case, make_list, make_set, get_origin_and_args_from_type_hint, get_value_type_from_type_hint, \
@@ -37,6 +39,24 @@ class CaseQuery:
     """
     Whether the attribute can only take one value (i.e. True) or multiple values (i.e. False).
     """
+    case_factory: Optional[Callable[[], Any]] = None
+    """
+    The factory method that can be used to recreate the original case.
+    """
+    case_factory_idx: Optional[int] = None
+    """
+    This is used when the case factory is a list of cases, this index is used to select the case from the list.
+    """
+    case_conf: Optional[CaseConf] = None
+    """
+    The case configuration that is used to (re)create the original case, recommended to be used when you want to 
+    the case to persist in the rule base, this would allow it to be used for merging with other similar conclusion RDRs.
+    """
+    scenario: Optional[Callable] = None
+    """
+    The executable scenario is the root callable that recreates the situation that the case is 
+    created in, for example, when the case is created from a test function, this would be the test function itself.
+    """
     _target: Optional[CallableExpression] = None
     """
     The target expression of the attribute.
@@ -95,7 +115,7 @@ class CaseQuery:
         """
         if self._case is not None:
             return self._case
-        elif not isinstance(self.original_case, (Case, SQLTable)):
+        elif not isinstance(self.original_case, Case):
             self._case = create_case(self.original_case, max_recursion_idx=3)
         else:
             self._case = self.original_case
@@ -225,4 +245,43 @@ class CaseQuery:
                          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, is_function=self.is_function,
-                         function_args_type_hints=self.function_args_type_hints)
+                         function_args_type_hints=self.function_args_type_hints,
+                         case_factory=self.case_factory, case_factory_idx=self.case_factory_idx,
+                         case_conf=self.case_conf, scenario=self.scenario)
+
+
+@dataclass
+class CaseConf:
+    factory_method: Callable[[Any], Any] = MISSING
+
+    def create(self) -> Any:
+        return self.factory_method()
+
+
+@dataclass
+class CaseFactoryMetaData:
+    factory_method: Optional[Callable[[Optional[CaseConf]], Any]] = None
+    factory_idx: Optional[int] = None
+    case_conf: Optional[CaseConf] = None
+    scenario: Optional[Callable] = None
+
+    @classmethod
+    def from_case_query(cls, case_query: CaseQuery) -> CaseFactoryMetaData:
+        return cls(factory_method=case_query.case_factory, factory_idx=case_query.case_factory_idx,
+                   case_conf=case_query.case_conf, scenario=case_query.scenario)
+
+    def __repr__(self):
+        factory_method_repr = None
+        scenario_repr = None
+        if self.factory_method is not None:
+            factory_method_repr = get_function_representation(self.factory_method)
+        if self.scenario is not None:
+            scenario_repr = get_function_representation(self.scenario)
+        return (f"CaseFactoryMetaData("
+                f"factory_method={factory_method_repr}, "
+                f"factory_idx={self.factory_idx}, "
+                f"case_conf={self.case_conf},"
+                f" scenario={scenario_repr})")
+
+    def __str__(self):
+        return self.__repr__()

ripple_down_rules/experts.py

@@ -138,7 +138,12 @@ class Expert(ABC):
             os.makedirs(dir_name, exist_ok=True)
             with open(dir_name + '/__init__.py', 'w') as f:
                 f.write('# This is an empty init file to make the directory a package.\n')
-        action = 'w' if not self.append else 'a'
+        # Current file data
+        current_file_data = None
+        if os.path.exists(path + '.py'):
+            with open(path + '.py', 'r') as f:
+                current_file_data = f.read()
+        action = 'a' if self.append and current_file_data is not None else 'w'
         with open(path + '.py', action) as f:
             for scope, func_source in self.all_expert_answers:
                 if len(scope) > 0:
@@ -147,9 +152,11 @@ class Expert(ABC):
                     imports = ''
                 if func_source is not None:
                     uid = uuid.uuid4().hex
-                    func_source = encapsulate_user_input(func_source, CallableExpression.encapsulating_function + f'_{uid}')
+                    func_source = encapsulate_user_input(func_source, CallableExpression.get_encapsulating_function(f'_{uid}'))
                 else:
                     func_source = 'pass  # No user input provided for this case.\n'
+                if current_file_data is not None and func_source[1:] in current_file_data:
+                    continue
                 f.write(imports + func_source + '\n' + '\n\n\n\'===New Answer===\'\n\n\n')
 
     def load_answers(self, path: Optional[str] = None):
@@ -194,6 +201,7 @@ class Expert(ABC):
             answer = answer.strip('\n').strip()
             if 'def ' not in answer and 'pass' in answer:
                 self.all_expert_answers.append(({}, None))
+                continue
             scope = extract_imports(tree=ast.parse(answer))
             function_source = all_function_sources[i].replace(all_function_sources_names[i],
                                                               CallableExpression.encapsulating_function_name)
@@ -240,6 +248,7 @@ class Human(Expert):
             except IndexError:
                 self.use_loaded_answers = False
         if user_input is not None:
+            case_query.scope.update(loaded_scope)
             condition = CallableExpression(user_input, bool, scope=case_query.scope)
         else:
             user_input, condition = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conditions)
@@ -265,6 +274,7 @@ class Human(Expert):
             try:
                 loaded_scope, expert_input = self.all_expert_answers.pop(0)
                 if expert_input is not None:
+                    case_query.scope.update(loaded_scope)
                     expression = CallableExpression(expert_input, case_query.attribute_type,
                                                     scope=case_query.scope,
                                                     mutually_exclusive=case_query.mutually_exclusive)

ripple_down_rules/helpers.py

@@ -1,18 +1,65 @@
 from __future__ import annotations
 
 import os
+from types import ModuleType
 
+from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
+
+from .datastructures.case import create_case
 from .datastructures.dataclasses import CaseQuery
-from sqlalchemy.orm import Session
-from typing_extensions import Type, Optional, Callable, Any, Dict, TYPE_CHECKING
+from typing_extensions import Type, Optional, Callable, Any, Dict, TYPE_CHECKING, Union
 
-from .utils import get_func_rdr_model_path
+from .utils import get_func_rdr_model_name, copy_case, make_set, update_case
 from .utils import calculate_precision_and_recall
 
 if TYPE_CHECKING:
     from .rdr import RippleDownRules
 
 
+def general_rdr_classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDownRules]],
+                         case: Any, modify_original_case: bool = False,
+                         case_query: Optional[CaseQuery] = None) -> Dict[str, Any]:
+    """
+    Classify a case by going through all classifiers and adding the categories that are classified,
+     and then restarting the classification until no more categories can be added.
+
+    :param classifiers_dict: A dictionary mapping conclusion types to the classifiers that produce them.
+    :param case: The case to classify.
+    :param modify_original_case: Whether to modify the original case or create a copy and modify it.
+    :param case_query: The case query to extract metadata from if needed.
+    :return: The categories that the case belongs to.
+    """
+    conclusions = {}
+    case = create_case(case)
+    case_cp = copy_case(case) if not modify_original_case else case
+    while True:
+        new_conclusions = {}
+        for attribute_name, rdr in classifiers_dict.items():
+            pred_atts = rdr.classify(case_cp, case_query=case_query)
+            if pred_atts is None:
+                continue
+            if rdr.mutually_exclusive:
+                if attribute_name not in conclusions or \
+                        (attribute_name in conclusions and conclusions[attribute_name] != pred_atts):
+                    conclusions[attribute_name] = pred_atts
+                    new_conclusions[attribute_name] = pred_atts
+            else:
+                pred_atts = make_set(pred_atts)
+                if attribute_name in conclusions:
+                    pred_atts = {p for p in pred_atts if p not in conclusions[attribute_name]}
+                if len(pred_atts) > 0:
+                    new_conclusions[attribute_name] = pred_atts
+                    if attribute_name not in conclusions:
+                        conclusions[attribute_name] = set()
+                    conclusions[attribute_name].update(pred_atts)
+            if attribute_name in new_conclusions:
+                temp_case_query = CaseQuery(case_cp, attribute_name, rdr.conclusion_type, rdr.mutually_exclusive)
+                update_case(temp_case_query, new_conclusions)
+        if len(new_conclusions) == 0:
+            break
+    return conclusions
+
+
 def is_matching(classifier: Callable[[Any], Any], case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
     """
     :param classifier: The RDR classifier to check the prediction of.
@@ -32,20 +79,19 @@ def is_matching(classifier: Callable[[Any], Any], case_query: CaseQuery, pred_ca
 
 
 def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[RippleDownRules],
-                                  session: Optional[Session] = None, **rdr_kwargs) -> RippleDownRules:
+                                  **rdr_kwargs) -> RippleDownRules:
     """
     Load the RDR model of the function if it exists, otherwise create a new one.
 
     :param func: The function to load the model for.
     :param model_dir: The directory where the model is stored.
     :param rdr_type: The type of the RDR model to load.
-    :param session: The SQLAlchemy session to use.
     :param rdr_kwargs: Additional arguments to pass to the RDR constructor in the case of a new model.
     """
-    model_path = get_func_rdr_model_path(func, model_dir)
+    model_name = get_func_rdr_model_name(func)
+    model_path = os.path.join(model_dir, model_name, "rdr_metadata", f"{model_name}.json")
     if os.path.exists(model_path):
-        rdr = rdr_type.load(model_path)
-        rdr.session = session
+        rdr = rdr_type.load(load_dir=model_dir, model_name=model_name)
     else:
-        rdr = rdr_type(session=session, **rdr_kwargs)
+        rdr = rdr_type(**rdr_kwargs)
     return rdr