ripple-down-rules 0.5.95__py3-none-any.whl → 0.5.97__py3-none-any.whl

ripple_down_rules/__init__.py

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

ripple_down_rules/datastructures/callable_expression.py

@@ -267,10 +267,16 @@ class CallableExpression(SubclassJSONSerializer):
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> CallableExpression:
+        scope = {}
+        for k, v in data['scope'].items():
+            try:
+                scope[k] = get_type_from_string(v)
+            except ModuleNotFoundError:
+                pass
         return cls(user_input=data["user_input"],
                    conclusion_type=tuple(get_type_from_string(t) for t in data["conclusion_type"])
                    if data["conclusion_type"] else None,
-                   scope={k: get_type_from_string(v) for k, v in data["scope"].items()},
+                   scope=scope,
                    conclusion=SubclassJSONSerializer.from_json(data["conclusion"]),
                    mutually_exclusive=data["mutually_exclusive"])
 

ripple_down_rules/datastructures/dataclasses.py

@@ -139,7 +139,7 @@ class CaseQuery:
             attribute_types_str = f"Union[{', '.join([t.__name__ for t in self.core_attribute_type])}]"
         else:
             attribute_types_str = self.core_attribute_type[0].__name__
-        if list in self.attribute_type:
+        if all(t in self.attribute_type for t in [list, set]) and len(self.core_attribute_type) > 2:
             return f"List[{attribute_types_str}]"
         else:
             return attribute_types_str

ripple_down_rules/rdr.py

@@ -4,6 +4,7 @@ import importlib
 import os
 from abc import ABC, abstractmethod
 from copy import copy
+from types import NoneType
 
 from ripple_down_rules.datastructures.dataclasses import CaseFactoryMetaData
 from . import logger
@@ -144,7 +145,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         try:
             rdr.update_from_python(model_dir, package_name=package_name)
             rdr.to_json_file(json_file)
-        except (FileNotFoundError, ValueError) as e:
+        except (FileNotFoundError, ValueError, SyntaxError) as e:
             logger.warning(f"Could not load the python file for the model {model_name} from {model_dir}. "
                            f"Make sure the file exists and is valid.")
             rdr.save(save_dir=load_dir, model_name=model_name, package_name=package_name)
@@ -546,6 +547,8 @@ class RDRWithCodeWriter(RippleDownRules, ABC):
         main_types = set()
         main_types.add(self.case_type)
         main_types.update(make_set(self.conclusion_type))
+        main_types.update({Union, Optional})
+        defs_types.add(Union)
         main_types.update({Case, create_case})
         main_types = main_types.difference(defs_types)
         return main_types, defs_types, cases_types
@@ -673,12 +676,12 @@ class SingleClassRDR(RDRWithCodeWriter):
         :param case_query: The case query containing the case and the target category to compare the case with.
         """
         pred = self.evaluate(case)
-        conclusion = pred.conclusion(case) if pred is not None else None
+        conclusion = pred.conclusion(case) if pred is not None else self.default_conclusion
         if pred is not None and pred.fired and case_query is not None:
             if pred.corner_case_metadata is None and conclusion is not None \
                     and type(conclusion) in case_query.core_attribute_type:
                 pred.corner_case_metadata = CaseFactoryMetaData.from_case_query(case_query)
-        return conclusion if pred is not None and pred.fired else self.default_conclusion
+        return conclusion
 
     def evaluate(self, case: Case) -> SingleClassRule:
         """
@@ -689,9 +692,8 @@ class SingleClassRDR(RDRWithCodeWriter):
 
     def _write_to_python(self, model_dir: str, package_name: Optional[str] = None):
         super()._write_to_python(model_dir, package_name=package_name)
-        if self.default_conclusion is not None:
-            with open(model_dir + f"/{self.generated_python_file_name}.py", "a") as f:
-                f.write(f"{' ' * 4}else:\n{' ' * 8}return {self.default_conclusion}\n")
+        with open(model_dir + 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, filename: str, parent_indent: str = "",
                                            defs_file: Optional[str] = None, cases_file: Optional[str] = None,
@@ -719,7 +721,19 @@ class SingleClassRDR(RDRWithCodeWriter):
 
     @property
     def conclusion_type_hint(self) -> str:
-        return self.conclusion_type[0].__name__
+        all_types = set(list(self.conclusion_type) + [type(self.default_conclusion)])
+        if NoneType in all_types:
+            return f"Optional[{', '.join([t.__name__ for t in all_types if t is not NoneType])}]"
+        return f"Union[{', '.join([t.__name__ for t in all_types])}]"
+
+    def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
+        main_types, def_types, case_types = super()._get_types_to_import()
+        main_types.add(type(self.default_conclusion))
+        def_types.add(type(self.default_conclusion))
+        if self.default_conclusion is None:
+            main_types.add(Optional)
+            def_types.add(Optional)
+        return main_types, def_types, case_types
 
     @property
     def conclusion_type(self) -> Tuple[Type]:
@@ -857,8 +871,8 @@ class MultiClassRDR(RDRWithCodeWriter):
 
     def _get_types_to_import(self) -> Tuple[Set[Type], Set[Type], Set[Type]]:
         main_types, defs_types, cases_types = super()._get_types_to_import()
-        main_types.update({Set, Union, make_set})
-        defs_types.add(Union)
+        main_types.update({Set, make_set})
+        defs_types.update({List, Set})
         return main_types, defs_types, cases_types
 
     def update_start_rule(self, case_query: CaseQuery, expert: Expert):

ripple_down_rules/rdr_decorators.py

@@ -31,7 +31,8 @@ class RDRDecorator:
                  expert: Optional[Expert] = None,
                  update_existing_rules: bool = True,
                  viewer: Optional[RDRCaseViewer] = None,
-                 package_name: Optional[str] = None):
+                 package_name: Optional[str] = None,
+                 use_generated_classifier: bool = False):
         """
         :param models_dir: The directory to save/load the RDR models.
         :param output_type: The type of the output. This is used to create the RDR model.
@@ -47,6 +48,7 @@ class RDRDecorator:
          even if they gave an output.
         :param viewer: The viewer to use for the RDR model. If None, no viewer will be used.
         :param package_name: The package name to use for relative imports in the RDR model.
+        :param use_generated_classifier: If True, the function will use the generated classifier instead of the RDR model.
         :return: A decorator to use a GeneralRDR as a classifier that monitors and modifies the function's output.
         """
         self.rdr_models_dir = models_dir
@@ -60,6 +62,8 @@ class RDRDecorator:
         self.update_existing_rules = update_existing_rules
         self.viewer = viewer
         self.package_name = package_name
+        self.use_generated_classifier = use_generated_classifier
+        self.generated_classifier: Optional[Callable] = None
         self.load()
 
     def decorator(self, func: Callable) -> Callable:
@@ -67,17 +71,17 @@ class RDRDecorator:
         @wraps(func)
         def wrapper(*args, **kwargs) -> Optional[Any]:
 
-            if len(self.parsed_output_type) == 0:
-                self.parsed_output_type = self.parse_output_type(func, self.output_type, *args)
             if self.model_name is None:
                 self.initialize_rdr_model_name_and_load(func)
-            if self.expert is None:
-                self.expert = Human(viewer=self.viewer,
-                                    answers_save_path=self.rdr_models_dir + f'/{self.model_name}/expert_answers')
 
             func_output = {self.output_name: func(*args, **kwargs)}
 
             if self.fit:
+                if len(self.parsed_output_type) == 0:
+                    self.parsed_output_type = self.parse_output_type(func, self.output_type, *args)
+                if self.expert is None:
+                    self.expert = Human(viewer=self.viewer,
+                                        answers_save_path=self.rdr_models_dir + f'/{self.model_name}/expert_answers')
                 case_query = self.create_case_query_from_method(func, func_output,
                                                                 self.parsed_output_type,
                                                                 self.mutual_exclusive,
@@ -87,7 +91,13 @@ class RDRDecorator:
                                            viewer=self.viewer)
             else:
                 case, case_dict = self.create_case_from_method(func, func_output, *args, **kwargs)
-                output = self.rdr.classify(case)
+                if self.use_generated_classifier:
+                    if self.generated_classifier is None:
+                        model_path = os.path.join(self.rdr_models_dir, self.model_name)
+                        self.generated_classifier = self.rdr.get_rdr_classifier_from_python_file(model_path)
+                    output = self.generated_classifier(case)
+                else:
+                    output = self.rdr.classify(case)
 
             if self.output_name in output:
                 return output[self.output_name]

ripple_down_rules/rules.py

@@ -4,6 +4,7 @@ import logging
 import re
 from abc import ABC, abstractmethod
 from pathlib import Path
+from types import NoneType
 from uuid import uuid4
 
 from anytree import NodeMixin
@@ -162,6 +163,22 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             # use regex to replace the function name
             new_function_name = f"def conclusion_{self.uid}"
             conclusion_lines[0] = re.sub(r"def (\w+)", new_function_name, conclusion_lines[0])
+            # add type hint
+            if len(self.conclusion.conclusion_type) == 1:
+                hint = self.conclusion.conclusion_type[0].__name__
+            else:
+                if (all(t in self.conclusion.conclusion_type for t in [list, set])
+                        and len(self.conclusion.conclusion_type) > 2):
+                    type_names = [t.__name__ for t in self.conclusion.conclusion_type if t not in [list, set]]
+                    hint = f"List[{', '.join(type_names)}]"
+                else:
+                    if NoneType in self.conclusion.conclusion_type:
+                        type_names = [t.__name__ for t in self.conclusion.conclusion_type if t is not NoneType]
+                        hint = f"Optional[{', '.join(type_names)}]"
+                    else:
+                        type_names = [t.__name__ for t in self.conclusion.conclusion_type]
+                        hint = f"Union[{', '.join(type_names)}]"
+            conclusion_lines[0] = conclusion_lines[0].replace("):", f") -> {hint}:")
             func_call = f"{parent_indent}    return {new_function_name.replace('def ', '')}(case)\n"
             return "\n".join(conclusion_lines).strip(' '), func_call
         else:
@@ -184,6 +201,8 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
             # use regex to replace the function name
             new_function_name = f"def conditions_{self.uid}"
             conditions_lines[0] = re.sub(r"def (\w+)", new_function_name, conditions_lines[0])
+            # add type hint
+            conditions_lines[0] = conditions_lines[0].replace('):', ') -> bool:')
             def_code = "\n".join(conditions_lines)
             with open(defs_file, 'a') as f:
                 f.write(def_code.strip() + "\n\n\n")

ripple_down_rules/utils.py

@@ -918,6 +918,8 @@ def get_imports_from_types(type_objs: Iterable[Type],
                 name = type(tp).__qualname__
             else:
                 continue
+            if name == "NoneType":
+                module = "types"
             if module is None or module == 'builtins' or module.startswith('_')\
                 or module in sys.builtin_module_names or module in excluded_modules or "<" in module \
                     or name in exclueded_names:
@@ -1053,7 +1055,19 @@ def get_type_from_string(type_path: str):
     :param type_path: The path to the type.
     """
     module_path, class_name = type_path.rsplit(".", 1)
-    module = importlib.import_module(module_path)
+    try:
+        module = importlib.import_module(module_path)
+    except ModuleNotFoundError:
+        module_path_parts = module_path.split(".")
+        idx = -1
+        while True:
+            try:
+                module = importlib.import_module('.'.join(module_path_parts[:idx]))
+                break
+            except ModuleNotFoundError:
+                idx -= 1
+                if abs(idx) > len(module_path_parts):
+                    raise
     if module == builtins and class_name == 'NoneType':
         return type(None)
     return getattr(module, class_name)

{ripple_down_rules-0.5.95.dist-info → ripple_down_rules-0.5.97.dist-info}/METADATA

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

@@ -1,15 +1,15 @@
-ripple_down_rules/__init__.py,sha256=2YbCMVId4Rq_iPakA2uby2d6kRHClQ90FEJIWdgjG3c,100
+ripple_down_rules/__init__.py,sha256=S8_aIL6wZaWbPQRl_qf9q65NR3nW8mnLIrjc-Tqvvaw,100
 ripple_down_rules/experts.py,sha256=4-dMIVeMzFXCLYl_XBG_P7_Xs4sZih9-vZxCIPri6dA,12958
 ripple_down_rules/helpers.py,sha256=sY8nFbYdLOO6EG5UQugCCxjSjcCQsDUCPgawfQA4Ui8,4495
-ripple_down_rules/rdr.py,sha256=weOkaB2Z8PdudKJfSSdkCPYjk2o4Woduupg-_gHh2vU,55449
-ripple_down_rules/rdr_decorators.py,sha256=riAFmL8jc1rw9dFkNbT023CfB5FbmOWHNiVKO2bAXsE,9195
-ripple_down_rules/rules.py,sha256=iVevv6iZ-6L2IPI0ZYbBjxBymXEQMmJGRFhiKUS-NmA,20352
+ripple_down_rules/rdr.py,sha256=CPSjSmdzUN5meBakr9T6B-ZT1KmLjRAJ6JIL3UIRzyI,56132
+ripple_down_rules/rdr_decorators.py,sha256=JWJn2MAKJG1YbLLWUZMzYfS3t1mEOAi21S8NUY7hy0Q,9913
+ripple_down_rules/rules.py,sha256=Dk4yGCy5oV10mOv5rRLcmtIu9J60WBPol9b7ELFn6fY,21522
 ripple_down_rules/start-code-server.sh,sha256=otClk7VmDgBOX2TS_cjws6K0UwvgAUJhoA0ugkPCLqQ,949
-ripple_down_rules/utils.py,sha256=IDVcKd4YGGvFzO1KaGIEk9u8xh13MrpsFM97VmvTfyw,61881
+ripple_down_rules/utils.py,sha256=vFoz5HcRgkf7_s-zdWSg54xI9PCMcdDzcdFGdas7KBA,62350
 ripple_down_rules/datastructures/__init__.py,sha256=V2aNgf5C96Y5-IGghra3n9uiefpoIm_QdT7cc_C8cxQ,111
-ripple_down_rules/datastructures/callable_expression.py,sha256=f3wUPTrLa1INO-1qfgVz87ryrCABronfyq0_JKWoZCs,12800
+ripple_down_rules/datastructures/callable_expression.py,sha256=YHlEYc9Ye_4gYAqqj_TyCB363WpZ8lXH2LLRl1CCGe8,12934
 ripple_down_rules/datastructures/case.py,sha256=PJ7_-AdxYic6BO5z816piFODj6nU5J6Jt1YzTFH-dds,15510
-ripple_down_rules/datastructures/dataclasses.py,sha256=qoTFHV8Hi-X8VtfC9VdvH4tif73YjF3dUe8dyHXTYts,10993
+ripple_down_rules/datastructures/dataclasses.py,sha256=D-nrVEW_27njmDGkyiHRnq5lmqEdO8RHKnLb1mdnwrA,11054
 ripple_down_rules/datastructures/enums.py,sha256=ce7tqS0otfSTNAOwsnXlhsvIn4iW_Y_N3TNebF3YoZs,5700
 ripple_down_rules/user_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ripple_down_rules/user_interface/gui.py,sha256=_lgZAUXxxaBUFQJAHjA5TBPp6XEvJ62t-kSN8sPsocE,27379
@@ -17,8 +17,8 @@ ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=yp-F8YRWGhj1PLB3
 ripple_down_rules/user_interface/object_diagram.py,sha256=FEa2HaYR9QmTE6NsOwBvZ0jqmu3DKyg6mig2VE5ZP4Y,4956
 ripple_down_rules/user_interface/prompt.py,sha256=JceEUGYsd0lIvd-v2y3D3swoo96_C0lxfp3CxM7Vfts,8900
 ripple_down_rules/user_interface/template_file_creator.py,sha256=kwBbFLyN6Yx2NTIHPSwOoytWgbJDYhgrUOVFw_jkDQ4,13522
-ripple_down_rules-0.5.95.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.5.95.dist-info/METADATA,sha256=5sPvCDBc_3yV4wBp5f6YRDtQkmNrd1-d_Ce7ijm6NZ0,48214
-ripple_down_rules-0.5.95.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ripple_down_rules-0.5.95.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.5.95.dist-info/RECORD,,
+ripple_down_rules-0.5.97.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.5.97.dist-info/METADATA,sha256=ATXJ3z-nJQQ3aB9aFaEnEfXLJ7njVA1Kh1s40tJPBV0,48214
+ripple_down_rules-0.5.97.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ripple_down_rules-0.5.97.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.5.97.dist-info/RECORD,,