ripple-down-rules 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

ripple_down_rules/datastructures/dataclasses.py

@@ -8,7 +8,7 @@ from typing_extensions import Any, Optional, Dict, Type, Tuple, Union
 
 from .callable_expression import CallableExpression
 from .case import create_case, Case
-from ..utils import copy_case
+from ..utils import copy_case, make_list
 
 
 @dataclass
@@ -88,6 +88,7 @@ class CaseQuery:
         """
         :return: The type of the attribute.
         """
+        self._attribute_types = tuple(make_list(self._attribute_types))
         if not self.mutually_exclusive and (set not in self._attribute_types):
             self._attribute_types = tuple(list(self._attribute_types) + [set])
         return self._attribute_types
@@ -97,9 +98,7 @@ class CaseQuery:
         """
         Set the type of the attribute.
         """
-        if not isinstance(value, tuple):
-            value = (value,)
-        self._attribute_types = value
+        self._attribute_types = tuple(make_list(value))
 
     @property
     def name(self):

ripple_down_rules/rdr.py

@@ -22,7 +22,7 @@ from .experts import Expert, Human
 from .rules import Rule, SingleClassRule, MultiClassTopRule, MultiClassStopRule
 from .utils import draw_tree, make_set, copy_case, \
     get_hint_for_attribute, SubclassJSONSerializer, is_iterable, make_list, get_type_from_string, \
-    get_case_attribute_type, ask_llm
+    get_case_attribute_type, ask_llm, is_matching
 
 
 class RippleDownRules(SubclassJSONSerializer, ABC):
@@ -103,14 +103,14 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
                 target = {case_query.attribute_name: case_query.target(case_query.case)}
                 if len(targets) < len(case_queries):
                     targets.append(target)
-                match = self.is_matching(case_query, pred_cat)
+                match = is_matching(self.classify, case_query, pred_cat)
                 if not match:
                     print(f"Predicted: {pred_cat} but expected: {target}")
                 if animate_tree and self.start_rule.size > num_rules:
                     num_rules = self.start_rule.size
                     self.update_figures()
             i += 1
-            all_predictions = [1 if self.is_matching(case_query) else 0 for case_query in case_queries
+            all_predictions = [1 if is_matching(self.classify, case_query) else 0 for case_query in case_queries
                                if case_query.target is not None]
             all_pred = sum(all_predictions)
             print(f"Accuracy: {all_pred}/{len(targets)}")
@@ -124,43 +124,6 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             plt.ioff()
             plt.show()
 
-    def is_matching(self, case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
-        """
-        :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 = self.classify(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 = self.calculate_precision_and_recall(pred_cat, target)
-        return all(recall) and all(precision)
-
-    @staticmethod
-    def calculate_precision_and_recall(pred_cat: Dict[str, Any], target: Dict[str, Any]) -> Tuple[
-        List[bool], List[bool]]:
-        """
-        :param pred_cat: The predicted category.
-        :param target: The target category.
-        :return: The precision and recall of the classifier.
-        """
-        recall = []
-        precision = []
-        for pred_key, pred_value in pred_cat.items():
-            if pred_key not in target:
-                continue
-            precision.extend([v in make_set(target[pred_key]) for v in make_set(pred_value)])
-        for target_key, target_value in target.items():
-            if target_key not in pred_cat:
-                recall.append(False)
-                continue
-            recall.extend([v in make_set(pred_cat[target_key]) for v in make_set(target_value)])
-        return precision, recall
-
     def update_figures(self):
         """
         Update the figures of the classifier.
@@ -399,6 +362,12 @@ class SingleClassRDR(RDRWithCodeWriter):
         matched_rule = self.start_rule(case)
         return matched_rule if matched_rule else self.start_rule
 
+    def write_to_python_file(self, file_path: str, postfix: str = ""):
+        super().write_to_python_file(file_path, postfix)
+        if self.default_conclusion is not None:
+            with open(file_path + f"/{self.generated_python_file_name}.py", "a") as f:
+                f.write(f"{' '*4}else:\n{' '*8}return {self.default_conclusion}\n")
+
     def write_rules_as_source_code_to_file(self, rule: SingleClassRule, file: TextIOWrapper, parent_indent: str = "",
                                            defs_file: Optional[str] = None):
         """

ripple_down_rules/utils.py

@@ -33,6 +33,45 @@ import ast
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def is_matching(rdr_classifier: Callable[[Any], Any], case_query: CaseQuery, pred_cat: Optional[Dict[str, Any]] = None) -> bool:
+    """
+    :param rdr_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 = rdr_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 calculate_precision_and_recall(pred_cat: Dict[str, Any], target: Dict[str, Any]) -> Tuple[
+    List[bool], List[bool]]:
+    """
+    :param pred_cat: The predicted category.
+    :param target: The target category.
+    :return: The precision and recall of the classifier.
+    """
+    recall = []
+    precision = []
+    for pred_key, pred_value in pred_cat.items():
+        if pred_key not in target:
+            continue
+        precision.extend([v in make_set(target[pred_key]) for v in make_set(pred_value)])
+    for target_key, target_value in target.items():
+        if target_key not in pred_cat:
+            recall.append(False)
+            continue
+        recall.extend([v in make_set(pred_cat[target_key]) for v in make_set(target_value)])
+    return precision, recall
+
+
 def get_rule_conclusion_as_source_code(rule: Rule, conclusion: str, parent_indent: str = "") -> str:
     """
     Convert the conclusion of a rule to source code.

{ripple_down_rules-0.1.5.dist-info → ripple_down_rules-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.5
+Version: 0.1.6
 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.5.dist-info → ripple_down_rules-0.1.6.dist-info}/RECORD

@@ -4,17 +4,17 @@ ripple_down_rules/experts.py,sha256=sA9Cmx9BlwlCFYRDDLz3VG6e5njujAFZEItSnnzrG5E,
 ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
 ripple_down_rules/helpers.py,sha256=AhqerAQoCdSovJ7SdQrNtAI_hYagKpLsy2nJQGA0bl0,1062
 ripple_down_rules/prompt.py,sha256=6g-WqMiOFp9QyAZDmiNbHbPjAeeJHb6ItLGdQAVxGKk,6063
-ripple_down_rules/rdr.py,sha256=HevACyk22k2m7sTKDTxbFiRp4MOQNK7XSOvJyVBg20Q,50047
+ripple_down_rules/rdr.py,sha256=VT7AWTDlLOyk2FILa4mHixdno2kXtk82m_pSY1CoEiE,48789
 ripple_down_rules/rdr_decorators.py,sha256=8SclpceI3EtrsbuukWJu8HGLh7Q1ZCgYGLX-RPlG-w0,2018
 ripple_down_rules/rules.py,sha256=KTB7kPnyyU9GuZhVe9ba25-3ICdzl46r9MFduckk-_Y,16147
-ripple_down_rules/utils.py,sha256=0yyLpvt-GEamV4Z3515ip200IfzpqOhNcrXhGzZtEPk,30521
+ripple_down_rules/utils.py,sha256=ppKTt3_O6JgmTqCdkjVBfuVaI6P7b4oRCSOmnBaqaVM,32110
 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=A7qkl5W48zldTtA4m-NJRYEwlMBpo7uGugnriNwcY0E,13597
-ripple_down_rules/datastructures/dataclasses.py,sha256=2HISRjO_rfsOVCD19bmWkR5tRK9kWyFGTn3QHdMfLSw,5829
+ripple_down_rules/datastructures/dataclasses.py,sha256=inhTE4tlMrwVRcYDtqAaR0JlxlyD87JIUvXIu5H9Ioo,5860
 ripple_down_rules/datastructures/enums.py,sha256=l0Eu-TeJ6qB2XHoJycXmUgLw-3yUebQ8SsEbW8bBZdM,4543
-ripple_down_rules-0.1.5.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.1.5.dist-info/METADATA,sha256=zjPgcX0Z3DMcPnU5YjbVRPu8w2MhdQ4gimpdC9JabJk,42518
-ripple_down_rules-0.1.5.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-ripple_down_rules-0.1.5.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.1.5.dist-info/RECORD,,
+ripple_down_rules-0.1.6.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.1.6.dist-info/METADATA,sha256=aoGSheQJpGvz7fNTP9jyKz0V1M416oOQfzgsT_8Sd5s,42518
+ripple_down_rules-0.1.6.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
+ripple_down_rules-0.1.6.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.1.6.dist-info/RECORD,,