ripple-down-rules 0.5.4__tar.gz → 0.5.7__tar.gz

{ripple_down_rules-0.5.4 → ripple_down_rules-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.4
+Version: 0.5.7
 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
@@ -693,7 +693,8 @@ Requires-Dist: colorama
 Requires-Dist: pygments
 Requires-Dist: sqlalchemy
 Requires-Dist: pandas
-Requires-Dist: pyparsing
+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"
@@ -799,6 +800,19 @@ cat = grdr.classify(all_cases[50])['species']
 assert cat == targets[50]
 ```
 
+When prompted to write a rule, I wrote the following inside the template function that the Ripple Down Rules created:
+```python
+return case.milk == 1
+```
+then
+```python
+return case.aquatic == 1
+```
+
+The rule tree generated from fitting all the dataset will look like this:
+![species_rdr](https://raw.githubusercontent.com/AbdelrhmanBassiouny/ripple_down_rules/main/images/scrdr.png)
+
+
 ### Relational Example
 
 By relational, I mean that each rule conclusion is not a constant value, but is related to the case being classified,

{ripple_down_rules-0.5.4 → ripple_down_rules-0.5.7}/README.md

@@ -95,6 +95,19 @@ cat = grdr.classify(all_cases[50])['species']
 assert cat == targets[50]
 ```
 
+When prompted to write a rule, I wrote the following inside the template function that the Ripple Down Rules created:
+```python
+return case.milk == 1
+```
+then
+```python
+return case.aquatic == 1
+```
+
+The rule tree generated from fitting all the dataset will look like this:
+![species_rdr](https://raw.githubusercontent.com/AbdelrhmanBassiouny/ripple_down_rules/main/images/scrdr.png)
+
+
 ### Relational Example
 
 By relational, I mean that each rule conclusion is not a constant value, but is related to the case being classified,

{ripple_down_rules-0.5.4 → ripple_down_rules-0.5.7}/doc/intro.md

@@ -13,27 +13,39 @@ SCRDR, MCRDR, and GRDR logic were inspired from the book:
 ["Ripple Down Rules: An Alternative to Machine Learning"](https://www.taylorfrancis.com/books/mono/10.1201/9781003126157/ripple-rules-paul-compton-byeong-ho-kang) by Paul Compton, Byeong Ho Kang.
 
 
-Additionally, to the main ripple down rules benefits, this package also features:
-
-- Ontology and Rule base as one entity
-    - Both use same python data structures.
-    - Update in data structures reflects in Rule base.
-    - Both are under one versioning system, the rule base is generated as a python module that becomes part of your
-    project.
-- First, second, and higher order logic is achieved by freely writing python code.
-    - Rule conditions and conclusions are python functions that can do anything that python can do.
-- Automatic maintenance of rule base.
-    - When rules are added contradictions are detected and prompted to the user to add a refinement rule for
-  to resolve the contradiction.
-- Transparent Editable rule base
-    - Rules are understandable python code that can be manually edited and reloaded.
-- Interface that makes coders feel at home by using their favorite IDE.
-- Uses latest technologies like LLMs to help in writing the rules (Inherited feature from IDEs).
-    - Auto completions and suggestions in the IDE.
-    - Ask AI available with the press of a button to help in writing the rule.
-- Rules can be for instances on very specific scenarios and can be very general on super class relations.
-- Accompanied by a GUI with an object explorer panel and an expandable/retractable object diagram to help in
-writing the rules about the object at hand.
+## 🚀 Enhanced Ripple-Down Rules Engine – Key Features
+
+### 🧠 Ontology + Rule Base as One Entity
+- 🧬 Unified data structure: Ontology and rules use the same Python data structures. 
+- 🔄 Automatic sync: Updates to the ontology instantly reflect in the rule base. 
+- 📦 Version controlled: The rule base is a Python module, versioned with your project.
+
+### 🔁 Supports First, Second & Higher-Order Logic
+- 🧩 Unlimited expressiveness: Rule conditions and conclusions are plain Python functions — anything Python can do, your rules can too!
+
+### 🛡️ Automatic Rule Base Maintenance 
+- ⚠️ Contradiction detection: New rules are auto-checked for logical conflicts. 
+- 🔧 Prompted refinements: If a contradiction arises, you're guided to add a refinement rule. 
+
+### 📝 Transparent & Editable Rule Base
+- 📖 Readable rules: Rules are clean, understandable Python code. 
+- 🔄 Reload-friendly: Easily edit and reload rules manually as needed.
+
+### 💻 Developer-Centric Interface
+- 👨‍💻 Feels like home: Seamless integration with your favorite IDE.
+- ✨ Modern coding experience: Auto-completion and suggestions supported via IDE plugins.
+
+### 🤖 LLM-Powered Rule Writing
+- 💡 AI-assisted authoring: Ask AI for help or suggestions directly within the IDE.
+- ⚡ Smart completion: Context-aware completions streamline rule writing.
+
+### 🎯 Flexible Rule Specificity
+- 🧪 Instance-level precision: Write rules for highly specific object scenarios.
+- 🏛️ Generalization-ready: Create broad rules for superclass relationships.
+
+### 🖼️ GUI for Rule Exploration
+- 🧭 Object Explorer Panel: Navigate and inspect objects easily.
+- 🧯 Interactive Diagram: Expandable/collapsible object diagram to guide rule creation visually.
 
 This work aims to provide a flexible and powerful rule-based system that can be used in various applications,
 from simple classification tasks to complex decision-making systems. Furthermore, one of the main goals is to
@@ -186,6 +198,19 @@ cat = grdr.classify(all_cases[50])['species']
 assert cat == targets[50]
 ```
 
+When prompted to write a rule, I wrote the following inside the template function that the Ripple Down Rules created:
+```python
+return case.milk == 1
+```
+then
+```python
+return case.aquatic == 1
+```
+
+The rule tree generated from fitting all the dataset will look like this:
+![species_rdr](https://raw.githubusercontent.com/AbdelrhmanBassiouny/ripple_down_rules/main/images/scrdr.png)
+
+
 ### Relational Example
 
 By relational, I mean that each rule conclusion is not a constant value, but is related to the case being classified,

{ripple_down_rules-0.5.4 → ripple_down_rules-0.5.7}/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.7/images/scrdr.dot

@@ -0,0 +1,127 @@
+digraph tree {
+    "def _get_value(case):
+    return case.milk == 1
+=> def _get_value(case):
+    return Species.mammal";
+    "def _get_value(case):
+    return case.aquatic == 1
+=> def _get_value(case):
+    return Species.fish";
+    "def _get_value(case):
+    return case.feathers == 1
+=> def _get_value(case):
+    return Species.bird";
+    "def _get_value(case):
+    return case.backbone == 0 and case.breathes == 0
+=> def _get_value(case):
+    return Species.molusc";
+    "def _get_value(case):
+    return case.eggs == 1 and case.backbone == 0
+=> def _get_value(case):
+    return Species.insect";
+    "def _get_value(case):
+    return case.backbone == 1 and case.tail == 1
+=> def _get_value(case):
+    return Species.reptile";
+    "def _get_value(case):
+    return case.backbone == 0 and case.eggs == 0
+=> def _get_value(case):
+    return Species.molusc";
+    "def _get_value(case):
+    return case.legs == 0
+=> def _get_value(case):
+    return Species.molusc";
+    "def _get_value(case):
+    return case.fins == 0
+=> def _get_value(case):
+    return Species.molusc";
+    "def _get_value(case):
+    return case.feathers == 1
+=> def _get_value(case):
+    return Species.bird_1";
+    "def _get_value(case):
+    return case.backbone == 1
+=> def _get_value(case):
+    return Species.amphibian";
+    "def _get_value(case):
+    return case.breathes == 0
+=> def _get_value(case):
+    return Species.reptile";
+    "def _get_value(case):
+    return case.milk == 1
+=> def _get_value(case):
+    return Species.mammal" -> "def _get_value(case):
+    return case.aquatic == 1
+=> def _get_value(case):
+    return Species.fish" [style="bold", label=" else if"];
+    "def _get_value(case):
+    return case.aquatic == 1
+=> def _get_value(case):
+    return Species.fish" -> "def _get_value(case):
+    return case.feathers == 1
+=> def _get_value(case):
+    return Species.bird" [style="bold", label=" else if"];
+    "def _get_value(case):
+    return case.aquatic == 1
+=> def _get_value(case):
+    return Species.fish" -> "def _get_value(case):
+    return case.fins == 0
+=> def _get_value(case):
+    return Species.molusc" [style="bold", label=" except if"];
+    "def _get_value(case):
+    return case.feathers == 1
+=> def _get_value(case):
+    return Species.bird" -> "def _get_value(case):
+    return case.backbone == 0 and case.breathes == 0
+=> def _get_value(case):
+    return Species.molusc" [style="bold", label=" else if"];
+    "def _get_value(case):
+    return case.backbone == 0 and case.breathes == 0
+=> def _get_value(case):
+    return Species.molusc" -> "def _get_value(case):
+    return case.eggs == 1 and case.backbone == 0
+=> def _get_value(case):
+    return Species.insect" [style="bold", label=" else if"];
+    "def _get_value(case):
+    return case.eggs == 1 and case.backbone == 0
+=> def _get_value(case):
+    return Species.insect" -> "def _get_value(case):
+    return case.backbone == 1 and case.tail == 1
+=> def _get_value(case):
+    return Species.reptile" [style="bold", label=" else if"];
+    "def _get_value(case):
+    return case.eggs == 1 and case.backbone == 0
+=> def _get_value(case):
+    return Species.insect" -> "def _get_value(case):
+    return case.legs == 0
+=> def _get_value(case):
+    return Species.molusc" [style="bold", label=" except if"];
+    "def _get_value(case):
+    return case.backbone == 1 and case.tail == 1
+=> def _get_value(case):
+    return Species.reptile" -> "def _get_value(case):
+    return case.backbone == 0 and case.eggs == 0
+=> def _get_value(case):
+    return Species.molusc" [style="bold", label=" else if"];
+    "def _get_value(case):
+    return case.fins == 0
+=> def _get_value(case):
+    return Species.molusc" -> "def _get_value(case):
+    return case.feathers == 1
+=> def _get_value(case):
+    return Species.bird_1" [style="bold", label=" except if"];
+    "def _get_value(case):
+    return case.feathers == 1
+=> def _get_value(case):
+    return Species.bird_1" -> "def _get_value(case):
+    return case.backbone == 1
+=> def _get_value(case):
+    return Species.amphibian" [style="bold", label=" else if"];
+    "def _get_value(case):
+    return case.backbone == 1
+=> def _get_value(case):
+    return Species.amphibian" -> "def _get_value(case):
+    return case.breathes == 0
+=> def _get_value(case):
+    return Species.reptile" [style="bold", label=" except if"];
+}

{ripple_down_rules-0.5.4 → ripple_down_rules-0.5.7}/requirements.txt

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

{ripple_down_rules-0.5.4 → ripple_down_rules-0.5.7}/src/ripple_down_rules/__init__.py

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

{ripple_down_rules-0.5.4 → ripple_down_rules-0.5.7}/src/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-0.5.4 → ripple_down_rules-0.5.7}/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.4 → ripple_down_rules-0.5.7}/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.4 → ripple_down_rules-0.5.7}/src/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-0.5.7/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