ripple-down-rules 0.1.65__tar.gz → 0.1.66__tar.gz

{ripple_down_rules-0.1.65 → ripple_down_rules-0.1.66}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.65
+Version: 0.1.66
 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.65 → ripple_down_rules-0.1.66}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.1.65"
+version = "0.1.66"
 description = "Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning."
 readme = "README.md"
 authors = [{ name = "Abdelrhman Bassiouny", email = "abassiou@uni-bremen.de" }]

{ripple_down_rules-0.1.65 → ripple_down_rules-0.1.66}/src/ripple_down_rules/rdr.py

@@ -326,13 +326,10 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         """
         :return: The type of the conclusion of the RDR classifier.
         """
-        if isinstance(self.start_rule.conclusion, CallableExpression):
-            return self.start_rule.conclusion.conclusion_type
-        else:
-            conclusion = self.start_rule.conclusion
-            if isinstance(conclusion, set):
-                return type(list(conclusion)[0]), set
-            return (type(conclusion),)
+        all_types = []
+        for rule in [self.start_rule] + list(self.start_rule.descendants):
+            all_types.extend(list(rule.conclusion.conclusion_type))
+        return tuple(set(all_types))
 
     @property
     def attribute_name(self) -> str:
@@ -419,7 +416,8 @@ class SingleClassRDR(RDRWithCodeWriter):
                 self.write_rules_as_source_code_to_file(rule.refinement, file, parent_indent + "    ",
                                                         defs_file=defs_file)
 
-            file.write(rule.write_conclusion_as_source_code(parent_indent))
+            conclusion_call = rule.write_conclusion_as_source_code(parent_indent, defs_file)
+            file.write(conclusion_call)
 
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent, defs_file=defs_file)
@@ -532,18 +530,20 @@ class MultiClassRDR(RDRWithCodeWriter):
                                                         defs_file=defs_file)
                 conclusion_indent = parent_indent + " " * 4
                 file.write(f"{conclusion_indent}else:\n")
-            file.write(rule.write_conclusion_as_source_code(conclusion_indent))
+
+            conclusion_call = rule.write_conclusion_as_source_code(conclusion_indent, defs_file)
+            file.write(conclusion_call)
 
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent, defs_file=defs_file)
 
     @property
     def conclusion_type_hint(self) -> str:
-        return f"Set[{self.conclusion_type[0].__name__}]"
+        return f"Set[Union[{', '.join([ct.__name__ for ct in self.conclusion_type if ct not in [list, set]])}]]"
 
     def _get_imports(self) -> str:
         imports = super()._get_imports()
-        imports += "from typing_extensions import Set\n"
+        imports += "from typing_extensions import Set, Union\n"
         imports += "from ripple_down_rules.utils import make_set\n"
         return imports
 
@@ -871,7 +871,7 @@ class GeneralRDR(RippleDownRules):
 
     @property
     def conclusion_type_hint(self) -> str:
-        return f"List[Union[{', '.join([rdr.conclusion_type_hint for rdr in self.start_rules_dict.values()])}]]"
+        return f"Dict[str, Any]"
 
     def _get_imports(self, file_path: str) -> str:
         """
@@ -882,7 +882,7 @@ class GeneralRDR(RippleDownRules):
         """
         imports = ""
         # add type hints
-        imports += f"from typing_extensions import List, Union, Set\n"
+        imports += f"from typing_extensions import Dict, Any, Union, Set\n"
         # import rdr type
         imports += f"from ripple_down_rules.rdr import GeneralRDR\n"
         # add case type

{ripple_down_rules-0.1.65 → ripple_down_rules-0.1.66}/src/ripple_down_rules/rules.py

@@ -5,7 +5,7 @@ from abc import ABC, abstractmethod
 from enum import Enum
 
 from anytree import NodeMixin
-from typing_extensions import List, Optional, Self, Union, Dict, Any
+from typing_extensions import List, Optional, Self, Union, Dict, Any, Tuple
 
 from .datastructures.callable_expression import CallableExpression
 from .datastructures.case import Case
@@ -78,24 +78,26 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         """
         pass
 
-    def write_conclusion_as_source_code(self, parent_indent: str = "") -> str:
+    def write_conclusion_as_source_code(self, parent_indent: str = "", defs_file: Optional[str] = None) -> str:
         """
         Get the source code representation of the conclusion of the rule.
 
         :param parent_indent: The indentation of the parent rule.
+        :param defs_file: The file to write the conclusion to if it is a definition.
+        :return: The source code representation of the conclusion of the rule.
         """
-        conclusion = self.conclusion
-        if isinstance(conclusion, CallableExpression):
-            if self.conclusion.user_input is not None:
-                conclusion = self.conclusion.user_input
-            else:
-                conclusion = self.conclusion.conclusion
-        if isinstance(conclusion, Enum):
-            conclusion = str(conclusion)
-        return self._conclusion_source_code(conclusion, parent_indent=parent_indent)
+        if self.conclusion.user_input is not None:
+            conclusion = self.conclusion.user_input
+        else:
+            conclusion = self.conclusion.conclusion
+        conclusion_func, conclusion_func_call = self._conclusion_source_code(conclusion, parent_indent=parent_indent)
+        if conclusion_func is not None:
+            with open(defs_file, 'a') as f:
+                f.write(conclusion_func + "\n\n")
+        return conclusion_func_call
 
     @abstractmethod
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
+    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[Optional[str], str]:
         pass
 
     def write_condition_as_source_code(self, parent_indent: str = "", defs_file: Optional[str] = None) -> str:
@@ -118,7 +120,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             conditions_lines[0] = re.sub(r"def (\w+)", new_function_name, conditions_lines[0])
             def_code = "\n".join(conditions_lines)
             with open(defs_file, 'a') as f:
-                f.write(def_code + "\n")
+                f.write(def_code + "\n\n")
             return f"\n{parent_indent}{if_clause} {new_function_name.replace('def ', '')}(case):\n"
 
     @abstractmethod
@@ -266,11 +268,11 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
         loaded_rule.alternative = SingleClassRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
+    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 f"{indent}return {conclusion}\n"
+            return None, f"{indent}return {conclusion}\n"
         else:
             return get_rule_conclusion_as_source_code(self, conclusion, parent_indent=parent_indent)
 
@@ -317,8 +319,8 @@ class MultiClassStopRule(Rule, HasAlternativeRule):
         loaded_rule.alternative = MultiClassStopRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
-        return f"{parent_indent}{' ' * 4}pass\n"
+    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[None, str]:
+        return None, f"{parent_indent}{' ' * 4}pass\n"
 
     def _if_statement_source_code_clause(self) -> str:
         return "elif" if self.weight == RDREdge.Alternative.value else "if"
@@ -362,25 +364,23 @@ class MultiClassTopRule(Rule, HasRefinementRule, HasAlternativeRule):
         loaded_rule.alternative = MultiClassTopRule.from_json(data["alternative"])
         return loaded_rule
 
-    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> str:
+    def _conclusion_source_code(self, conclusion: Any, parent_indent: str = "") -> Tuple[str, str]:
         conclusion_str = str(conclusion)
         indent = parent_indent + " " * 4
-        statement = ""
         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:
-            conclusion_str = get_rule_conclusion_as_source_code(self, conclusion_str, parent_indent=parent_indent)
-            lines = conclusion_str.split("\n")
-            conclusion_str = lines[-2].replace("return ", "").strip()
-            statement += "\n".join(lines[:-2]) + "\n"
+            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"
+        statement = f"{indent}conclusions.update(make_set({conclusion_str}))\n"
         if self.alternative is None:
             statement += f"{parent_indent}return conclusions\n"
-        return statement
+        return func, statement
 
     def _if_statement_source_code_clause(self) -> str:
         return "if"

{ripple_down_rules-0.1.65 → ripple_down_rules-0.1.66}/src/ripple_down_rules/utils.py

@@ -119,14 +119,14 @@ def calculate_precision_and_recall(pred_cat: Dict[str, Any], target: Dict[str, A
     return precision, recall
 
 
-def get_rule_conclusion_as_source_code(rule: Rule, conclusion: str, parent_indent: str = "") -> str:
+def get_rule_conclusion_as_source_code(rule: Rule, conclusion: str, parent_indent: str = "") -> Tuple[str, str]:
     """
     Convert the conclusion of a rule to source code.
 
     :param rule: The rule to get the conclusion from.
     :param conclusion: The conclusion to convert to source code.
     :param parent_indent: The indentation to use for the source code.
-    :return: The source code of the conclusion.
+    :return: The source code of the conclusion as a tuple of strings, one for the function and one for the call.
     """
     indent = f"{parent_indent}{' ' * 4}"
     if "def " in conclusion:
@@ -135,9 +135,8 @@ def get_rule_conclusion_as_source_code(rule: Rule, conclusion: str, parent_inden
         # use regex to replace the function name
         new_function_name = f"def conclusion_{id(rule)}"
         conclusion_lines[0] = re.sub(r"def (\w+)", new_function_name, conclusion_lines[0])
-        conclusion_lines = [f"{indent}{line}" for line in conclusion_lines]
-        conclusion_lines.append(f"{indent}return {new_function_name.replace('def ', '')}(case)\n")
-        return "\n".join(conclusion_lines)
+        func_call = f"{indent}return {new_function_name.replace('def ', '')}(case)\n"
+        return "\n".join(conclusion_lines).strip(' '), func_call
     else:
         raise ValueError(f"Conclusion is format is not valid, it should be a one line string or "
                          f"contain a function definition. Instead got:\n{conclusion}\n")

{ripple_down_rules-0.1.65 → ripple_down_rules-0.1.66}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.1.65
+Version: 0.1.66
 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