ripple-down-rules 0.1.66__py3-none-any.whl → 0.1.67__py3-none-any.whl

ripple_down_rules/datasets.py

@@ -125,7 +125,7 @@ class HabitatTable(MappedAsDataclass, Base):
         return hash(self.habitat)
 
     def __str__(self):
-        return self.habitat.value
+        return f"{HabitatTable.__name__}({Habitat.__name__}.{self.habitat.name})"
 
     def __repr__(self):
         return self.__str__()

ripple_down_rules/datastructures/callable_expression.py

@@ -3,11 +3,13 @@ from __future__ import annotations
 import ast
 import logging
 from _ast import AST
+from enum import Enum
 
 from typing_extensions import Type, Optional, Any, List, Union, Tuple, Dict, Set
 
 from .case import create_case, Case
-from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string, conclusion_to_json, is_iterable
+from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string, conclusion_to_json, is_iterable, \
+    build_user_input_from_conclusion, encapsulate_user_input
 
 
 class VariableVisitor(ast.NodeVisitor):
@@ -88,6 +90,7 @@ class CallableExpression(SubclassJSONSerializer):
     """
     A callable that is constructed from a string statement written by an expert.
     """
+    encapsulating_function: str = "def _get_value(case):"
 
     def __init__(self, user_input: Optional[str] = None, conclusion_type: Optional[Tuple[Type]] = None,
                  expression_tree: Optional[AST] = None,
@@ -103,8 +106,10 @@ class CallableExpression(SubclassJSONSerializer):
         """
         if user_input is None and conclusion is None:
             raise ValueError("Either user_input or conclusion must be provided.")
+        if user_input is None:
+            user_input = build_user_input_from_conclusion(conclusion)
         self.conclusion: Optional[Any] = conclusion
-        self.user_input: str = user_input
+        self.user_input: str = encapsulate_user_input(user_input, self.encapsulating_function)
         if conclusion_type is not None:
             if is_iterable(conclusion_type):
                 conclusion_type = tuple(conclusion_type)
@@ -112,12 +117,11 @@ class CallableExpression(SubclassJSONSerializer):
                 conclusion_type = (conclusion_type,)
         self.conclusion_type = conclusion_type
         self.scope: Optional[Dict[str, Any]] = scope if scope is not None else {}
-        if conclusion is None:
-            self.scope = get_used_scope(self.user_input, self.scope)
-            self.expression_tree: AST = expression_tree if expression_tree else parse_string_to_expression(self.user_input)
-            self.code = compile_expression_to_code(self.expression_tree)
-            self.visitor = VariableVisitor()
-            self.visitor.visit(self.expression_tree)
+        self.scope = get_used_scope(self.user_input, self.scope)
+        self.expression_tree: AST = expression_tree if expression_tree else parse_string_to_expression(self.user_input)
+        self.code = compile_expression_to_code(self.expression_tree)
+        self.visitor = VariableVisitor()
+        self.visitor.visit(self.expression_tree)
 
     def __call__(self, case: Any, **kwargs) -> Any:
         try:
@@ -145,7 +149,11 @@ class CallableExpression(SubclassJSONSerializer):
         """
         Combine this callable expression with another callable expression using the 'and' operator.
         """
-        new_user_input = f"({self.user_input}) and ({other.user_input})"
+        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):")
+        new_user_input = (f"{cond1_user_input}\n"
+                          f"{cond2_user_input}\n"
+                          f"return _cond1(case) and _cond2(case)")
         return CallableExpression(new_user_input, conclusion_type=self.conclusion_type)
 
     def __eq__(self, other):

ripple_down_rules/datastructures/dataclasses.py

@@ -120,7 +120,7 @@ class CaseQuery:
         """
         :return: The target expression of the attribute.
         """
-        if self._target is not None and not isinstance(self._target, CallableExpression):
+        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)
         return self._target

ripple_down_rules/prompt.py

@@ -80,16 +80,10 @@ class IPythonShell:
             self.user_input = None
         else:
             self.all_code_lines = extract_dependencies(self.shell.all_lines)
-            if len(self.all_code_lines) == 1:
-                if self.all_code_lines[0].strip() == '':
-                    self.user_input = None
-                else:
-                    self.user_input = self.all_code_lines[0].replace('return', '').strip()
+            if len(self.all_code_lines) == 1 and self.all_code_lines[0].strip() == '':
+                self.user_input = None
             else:
-                self.user_input = f"def _get_value(case):\n    "
-                for cl in self.all_code_lines:
-                    sub_code_lines = cl.split('\n')
-                    self.user_input += '\n    '.join(sub_code_lines) + '\n    '
+                self.user_input = '\n'.join(self.all_code_lines)
 
 
 def prompt_user_for_expression(case_query: CaseQuery, prompt_for: PromptFor, prompt_str: Optional[str] = None)\

ripple_down_rules/rdr.py

@@ -715,7 +715,7 @@ class GeneralRDR(RippleDownRules):
 
     @staticmethod
     def _classify(classifiers_dict: Dict[str, Union[ModuleType, RippleDownRules]],
-                  case: Any, modify_original_case: bool = True) -> Dict[str, Any]:
+                  case: Any, modify_original_case: bool = False) -> 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.

ripple_down_rules/rules.py

@@ -270,11 +270,11 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
 
     def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[Optional[str], str]:
         conclusion = str(conclusion)
-        indent = parent_indent + " " * 4
-        if '\n' not in conclusion:
-            return None, f"{indent}return {conclusion}\n"
-        else:
-            return get_rule_conclusion_as_source_code(self, conclusion, parent_indent=parent_indent)
+        # indent = parent_indent + " " * 4
+        # if '\n' not in conclusion:
+        #     return None, f"{indent}return {conclusion}\n"
+        # else:
+        return get_rule_conclusion_as_source_code(self, conclusion, parent_indent=parent_indent)
 
     def _if_statement_source_code_clause(self) -> str:
         return "elif" if self.weight == RDREdge.Alternative.value else "if"
@@ -367,15 +367,15 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
     def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[str, str]:
         conclusion_str = str(conclusion)
         indent = parent_indent + " " * 4
-        if '\n' not in conclusion_str:
-            func = None
-            if is_iterable(conclusion):
-                conclusion_str = "{" + ", ".join([str(c) for c in conclusion]) + "}"
-            else:
-                conclusion_str = "{" + str(conclusion) + "}"
-        else:
-            func, func_call = get_rule_conclusion_as_source_code(self, conclusion_str, parent_indent=parent_indent)
-            conclusion_str = func_call.replace("return ", "").strip()
+        # if '\n' not in conclusion_str:
+        #     func = None
+        #     if is_iterable(conclusion):
+        #         conclusion_str = "{" + ", ".join([str(c) for c in conclusion]) + "}"
+        #     else:
+        #         conclusion_str = "{" + str(conclusion) + "}"
+        # else:
+        func, func_call = get_rule_conclusion_as_source_code(self, conclusion_str, parent_indent=parent_indent)
+        conclusion_str = func_call.replace("return ", "").strip()
 
         statement = f"{indent}conclusions.update(make_set({conclusion_str}))\n"
         if self.alternative is None:

ripple_down_rules/utils.py

@@ -10,6 +10,7 @@ import re
 from collections import UserDict
 from copy import deepcopy
 from dataclasses import is_dataclass, fields
+from enum import Enum
 from types import NoneType
 
 import matplotlib
@@ -34,6 +35,58 @@ import ast
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def encapsulate_user_input(user_input: str, func_signature: str) -> str:
+    """
+    Encapsulate the user input string with a function definition.
+
+    :param user_input: The user input string.
+    :param func_signature: The function signature to use for encapsulation.
+    :return: The encapsulated user input string.
+    """
+    if func_signature not in user_input:
+        new_user_input = func_signature + "\n    "
+        if "return " not in user_input:
+            if '\n' not in user_input:
+                new_user_input += f"return {user_input}"
+            else:
+                raise ValueError("User input must contain a return statement or be a single line.")
+        else:
+            for cl in user_input.split('\n'):
+                sub_code_lines = cl.split('\n')
+                new_user_input += '\n    '.join(sub_code_lines) + '\n    '
+    else:
+        new_user_input = user_input
+    return new_user_input
+
+
+def build_user_input_from_conclusion(conclusion: Any) -> str:
+    """
+    Build a user input string from the conclusion.
+
+    :param conclusion: The conclusion to use for the callable expression.
+    :return: The user input string.
+    """
+
+    # set user_input to the string representation of the conclusion
+    if isinstance(conclusion, set):
+        user_input = '{' + f"{', '.join([conclusion_to_str(t) for t in conclusion])}" + '}'
+    elif isinstance(conclusion, list):
+        user_input = '[' + f"{', '.join([conclusion_to_str(t) for t in conclusion])}" + ']'
+    elif isinstance(conclusion, tuple):
+        user_input = '(' + f"{', '.join([conclusion_to_str(t) for t in conclusion])}" + ')'
+    else:
+        user_input = conclusion_to_str(conclusion)
+
+    return user_input
+
+
+def conclusion_to_str(conclusion_: Any) -> str:
+    if isinstance(conclusion_, Enum):
+        return type(conclusion_).__name__ + '.' + conclusion_.name
+    else:
+        return str(conclusion_)
+
+
 def update_case(case_query: CaseQuery, conclusions: Dict[str, Any]):
     """
     Update the case with the conclusions.

{ripple_down_rules-0.1.66.dist-info → ripple_down_rules-0.1.67.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.66
+Version: 0.1.67
 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.1.67.dist-info/RECORD

@@ -0,0 +1,20 @@
+ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/datasets.py,sha256=mjJh1GLD_5qMgHaukdDWSGphXS9k_BPEF001ZXPchr8,4687
+ripple_down_rules/experts.py,sha256=JGVvSNiWhm4FpRpg76f98tl8Ii_C7x_aWD9FxD-JDLQ,6130
+ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
+ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
+ripple_down_rules/prompt.py,sha256=gdLV2qhq-1kbmlJhVmkCwGGFhIeDxV0p5u2hwrbGUpk,6370
+ripple_down_rules/rdr.py,sha256=LNXkiS-Dc7inGPKvTxZDarYPFsw9mSEWB6YDHl58g2A,41536
+ripple_down_rules/rdr_decorators.py,sha256=8SclpceI3EtrsbuukWJu8HGLh7Q1ZCgYGLX-RPlG-w0,2018
+ripple_down_rules/rules.py,sha256=SxP94X7I0XImG5zuEWLDfmINihwBKL-h_j1v2EMcVtg,16557
+ripple_down_rules/utils.py,sha256=MABj84x3v6gF5j2HscoQXnAZnupAGio3WjtsrTtVlRo,36473
+ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
+ripple_down_rules/datastructures/callable_expression.py,sha256=4AxguiVeSTxzYti5AyOWHdqWzS6KdSPWqf0unR9ZuhA,9636
+ripple_down_rules/datastructures/case.py,sha256=uM5YkJOfYfARrZZ3oAxKMWE5QBSnvHLLZa9Atoxb7eY,13800
+ripple_down_rules/datastructures/dataclasses.py,sha256=TAOAeEvh0BeTis3rEHu8rpCeqNNhU0vK3to0JaBwTio,5961
+ripple_down_rules/datastructures/enums.py,sha256=RdyPUp9Ls1QuLmkcMMkBbCWrmXIZI4xWuM-cLPYZhR0,4666
+ripple_down_rules-0.1.67.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.1.67.dist-info/METADATA,sha256=qlVXkthupuQp5K2PIWp_aFfGVP28rGWW3UXDx2enFBc,42576
+ripple_down_rules-0.1.67.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+ripple_down_rules-0.1.67.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.1.67.dist-info/RECORD,,

ripple_down_rules-0.1.66.dist-info/RECORD

@@ -1,20 +0,0 @@
-ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules/datasets.py,sha256=rCSpeFeu1gTuKESwjHUdQkPPvomI5OMRNGpbdKmHwMg,4639
-ripple_down_rules/experts.py,sha256=JGVvSNiWhm4FpRpg76f98tl8Ii_C7x_aWD9FxD-JDLQ,6130
-ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
-ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
-ripple_down_rules/prompt.py,sha256=cHqhMJqubGhfGpOOY_uXv5L7PBNb64O0IBWSfiY0ui0,6682
-ripple_down_rules/rdr.py,sha256=iRoQcfXlCtAP9e_TxWY26ZZOv-Ki4MVRkmfPjlJ2vYY,41535
-ripple_down_rules/rdr_decorators.py,sha256=8SclpceI3EtrsbuukWJu8HGLh7Q1ZCgYGLX-RPlG-w0,2018
-ripple_down_rules/rules.py,sha256=Ms9uDDM7QaFrzzPB-nsPOWbIrT-QVqvhmHA4z8HQOgI,16547
-ripple_down_rules/utils.py,sha256=A4ArFvF4lTsjicfN2fV2oIIo2HSapA9LXb92sY6n-Rs,34538
-ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
-ripple_down_rules/datastructures/callable_expression.py,sha256=TW_u6CJfelW2CiJj9pWFpdOBNIxeEuhhsQEz_pLpFVE,9092
-ripple_down_rules/datastructures/case.py,sha256=uM5YkJOfYfARrZZ3oAxKMWE5QBSnvHLLZa9Atoxb7eY,13800
-ripple_down_rules/datastructures/dataclasses.py,sha256=V757VwxROlevXh5ZVFLVuzwY4JIJKG8ARlCfjhubfy8,5957
-ripple_down_rules/datastructures/enums.py,sha256=RdyPUp9Ls1QuLmkcMMkBbCWrmXIZI4xWuM-cLPYZhR0,4666
-ripple_down_rules-0.1.66.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.1.66.dist-info/METADATA,sha256=PFdnyrcmNvbrVchvwNW0zl19IkCPhmsCAcpJ3VYO49Y,42576
-ripple_down_rules-0.1.66.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-ripple_down_rules-0.1.66.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.1.66.dist-info/RECORD,,