ripple-down-rules 0.5.63__tar.gz → 0.5.71__tar.gz

{ripple_down_rules-0.5.63 → ripple_down_rules-0.5.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.63
+Version: 0.5.71
 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
@@ -694,6 +694,7 @@ Requires-Dist: pygments
 Requires-Dist: sqlalchemy
 Requires-Dist: pandas
 Requires-Dist: pyparsing>=3.2.3
+Requires-Dist: omegaconf
 Provides-Extra: viz
 Requires-Dist: networkx>=3.1; extra == "viz"
 Requires-Dist: matplotlib>=3.7.5; extra == "viz"

{ripple_down_rules-0.5.63 → ripple_down_rules-0.5.71}/examples/part_containment_rdr/robot_rdr.py

@@ -1,5 +1,6 @@
 from typing_extensions import Dict, Any
-from ripple_down_rules.rdr import GeneralRDR
+
+from ripple_down_rules.helpers import general_rdr_classify
 from ripple_down_rules.datastructures.case import Case, create_case
 from __main__ import Robot
 from . import robot_contained_objects_mcrdr as contained_objects_classifier
@@ -12,4 +13,4 @@ classifiers_dict['contained_objects'] = contained_objects_classifier
 def classify(case: Robot) -> Dict[str, Any]:
     if not isinstance(case, Case):
         case = create_case(case, max_recursion_idx=3)
-    return GeneralRDR._classify(classifiers_dict, case)
+    return general_rdr_classify(classifiers_dict, case)

{ripple_down_rules-0.5.63 → ripple_down_rules-0.5.71}/requirements.txt

@@ -10,4 +10,5 @@ colorama
 pygments
 sqlalchemy
 pandas
-pyparsing>=3.2.3
+pyparsing>=3.2.3
+omegaconf

{ripple_down_rules-0.5.63 → ripple_down_rules-0.5.71}/src/ripple_down_rules/__init__.py

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

{ripple_down_rules-0.5.63 → ripple_down_rules-0.5.71}/src/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-0.5.63 → ripple_down_rules-0.5.71}/src/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_path_and_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_import_path_and_representation(self.factory_method)
+        if self.scenario is not None:
+            _, scenario_repr = get_function_import_path_and_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-0.5.71/src/ripple_down_rules/helpers.py

@@ -0,0 +1,97 @@
+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 typing_extensions import Type, Optional, Callable, Any, Dict, TYPE_CHECKING, Union
+
+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.
+    :param case_query: The case query to check.
+    :param pred_cat: The predicted category.
+    :return: Whether the classifier prediction is matching case_query target or not.
+    """
+    if case_query.target is None:
+        return False
+    if pred_cat is None:
+        pred_cat = classifier(case_query.case)
+    if not isinstance(pred_cat, dict):
+        pred_cat = {case_query.attribute_name: pred_cat}
+    target = {case_query.attribute_name: case_query.target_value}
+    precision, recall = calculate_precision_and_recall(pred_cat, target)
+    return all(recall) and all(precision)
+
+
+def load_or_create_func_rdr_model(func, model_dir: str, rdr_type: Type[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 rdr_kwargs: Additional arguments to pass to the RDR constructor in the case of a new model.
+    """
+    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(load_dir=model_dir, model_name=model_name)
+    else:
+        rdr = rdr_type(**rdr_kwargs)
+    return rdr