ripple-down-rules 0.0.15__py3-none-any.whl → 0.1.1__py3-none-any.whl

ripple_down_rules/rdr_decorators.py

@@ -0,0 +1,55 @@
+"""
+This file contains decorators for the RDR (Ripple Down Rules) framework. Where each type of RDR has a decorator
+that can be used with any python function such that this function can benefit from the incremental knowledge acquisition
+of the RDRs.
+"""
+import os.path
+from functools import wraps
+from typing import Callable, Optional, Type
+
+from sqlalchemy.orm import Session
+from typing_extensions import Any
+
+from ripple_down_rules.datastructures import Case, Category, create_case, CaseQuery
+from ripple_down_rules.experts import Expert, Human
+
+from ripple_down_rules.rdr import SingleClassRDR, MultiClassRDR, GeneralRDR
+from ripple_down_rules.utils import get_method_args_as_dict, get_method_name, get_method_class_name_if_exists, \
+    get_method_file_name, get_func_rdr_model_path
+
+
+def single_class_rdr(
+    model_dir: str,
+    fit: bool = True,
+    expert: Optional[Expert] = None,
+    session: Optional[Session] = None,
+) -> Callable:
+    """
+    Decorator to use a SingleClassRDR as a classifier.
+    """
+    expert = expert if expert else Human(session=session)
+
+    def decorator(func: Callable) -> Callable:
+        scrdr_model_path = get_func_rdr_model_path(func, model_dir)
+        if os.path.exists(scrdr_model_path):
+            scrdr = SingleClassRDR.load(scrdr_model_path)
+            scrdr.session = session
+        else:
+            scrdr = SingleClassRDR(session=session)
+
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Category:
+            case_dict = get_method_args_as_dict(func, *args, **kwargs)
+            func_output = func(*args, **kwargs)
+            if func_output is not None:
+                case_dict.update({"_output": func_output})
+            case = create_case(case_dict, recursion_idx=3)
+            if fit:
+                output = scrdr.fit_case(CaseQuery(case), expert=expert)
+                scrdr.save(scrdr_model_path)
+                return output
+            else:
+                return scrdr.classify(case)
+        return wrapper
+
+    return decorator

ripple_down_rules/rules.py

@@ -21,7 +21,8 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
                  conclusion: Optional[CallableExpression] = None,
                  parent: Optional[Rule] = None,
                  corner_case: Optional[Union[Case, SQLTable]] = None,
-                 weight: Optional[str] = None):
+                 weight: Optional[str] = None,
+                 conclusion_name: Optional[str] = None):
         """
         A rule in the ripple down rules classifier.
 
@@ -30,6 +31,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         :param parent: The parent rule of this rule.
         :param corner_case: The corner case that this rule is based on/created from.
         :param weight: The weight of the rule, which is the type of edge connecting the rule to its parent.
+        :param conclusion_name: The name of the conclusion of the rule.
         """
         super(Rule, self).__init__()
         self.conclusion = conclusion
@@ -37,6 +39,7 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
         self.parent = parent
         self.weight: Optional[str] = weight
         self.conditions = conditions if conditions else None
+        self.conclusion_name: Optional[str] = conclusion_name
         self.json_serialization: Optional[Dict[str, Any]] = None
 
     def _post_detach(self, parent):
@@ -107,8 +110,10 @@ class Rule(NodeMixin, SubclassJSONSerializer, ABC):
                 conclusions = {'_type': get_full_class_name(type(conclusion)), 'value': []}
                 for c in conclusion:
                     conclusions['value'].append(conclusion_to_json(c))
-            else:
+            elif hasattr(conclusion, 'to_json'):
                 conclusions = conclusion.to_json()
+            else:
+                conclusions = {'_type': get_full_class_name(type(conclusion)), 'value': conclusion}
             return conclusions
 
         json_serialization = {"conditions": self.conditions.to_json(),

ripple_down_rules/utils.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
+import ast
 import importlib
 import json
 import logging
+import os
 from abc import abstractmethod
 from collections import UserDict
 from copy import deepcopy
-from dataclasses import dataclass
+from dataclasses import dataclass, is_dataclass, fields
 
 import matplotlib
 import networkx as nx
@@ -25,6 +27,162 @@ if TYPE_CHECKING:
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def serialize_dataclass(obj: Any) -> Union[Dict, Any]:
+    """
+    Recursively serialize a dataclass to a dictionary. If the dataclass contains any nested dataclasses, they will be
+    serialized as well. If the object is not a dataclass, it will be returned as is.
+
+    :param obj: The dataclass to serialize.
+    :return: The serialized dataclass as a dictionary or the object itself if it is not a dataclass.
+    """
+
+    def recursive_convert(obj):
+        if is_dataclass(obj):
+            return {
+                "__dataclass__": f"{obj.__class__.__module__}.{obj.__class__.__qualname__}",
+                "fields": {f.name: recursive_convert(getattr(obj, f.name)) for f in fields(obj)}
+            }
+        elif isinstance(obj, list):
+            return [recursive_convert(item) for item in obj]
+        elif isinstance(obj, dict):
+            return {k: recursive_convert(v) for k, v in obj.items()}
+        else:
+            return obj
+
+    return recursive_convert(obj)
+
+
+def deserialize_dataclass(data: dict) -> Any:
+    """
+    Recursively deserialize a dataclass from a dictionary, if the dictionary contains a key "__dataclass__" (Most likely
+    created by the serialize_dataclass function), it will be treated as a dataclass and deserialized accordingly,
+    otherwise it will be returned as is.
+
+    :param data: The dictionary to deserialize.
+    :return: The deserialized dataclass.
+    """
+    def recursive_load(obj):
+        if isinstance(obj, dict) and "__dataclass__" in obj:
+            module_name, class_name = obj["__dataclass__"].rsplit(".", 1)
+            module = importlib.import_module(module_name)
+            cls: Type = getattr(module, class_name)
+            field_values = {
+                k: recursive_load(v)
+                for k, v in obj["fields"].items()
+            }
+            return cls(**field_values)
+        elif isinstance(obj, list):
+            return [recursive_load(item) for item in obj]
+        elif isinstance(obj, dict):
+            return {k: recursive_load(v) for k, v in obj.items()}
+        else:
+            return obj
+
+    return recursive_load(data)
+
+
+def typing_to_python_type(typing_hint: Type) -> Type:
+    """
+    Convert a typing hint to a python type.
+
+    :param typing_hint: The typing hint to convert.
+    :return: The python type.
+    """
+    if typing_hint in [list, List]:
+        return list
+    elif typing_hint in [tuple, Tuple]:
+        return tuple
+    elif typing_hint in [set, Set]:
+        return set
+    elif typing_hint in [dict, Dict]:
+        return dict
+    else:
+        return typing_hint
+
+
+def capture_variable_assignment(code: str, variable_name: str) -> Optional[str]:
+    """
+    Capture the assignment of a variable in the given code.
+
+    :param code: The code to analyze.
+    :param variable_name: The name of the variable to capture.
+    :return: The assignment statement or None if not found.
+    """
+    tree = ast.parse(code)
+    assignment = None
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name) and target.id == variable_name:
+                    # now extract the right side of the assignment
+                    assignment = ast.get_source_segment(code, node.value)
+                    break
+        if assignment is not None:
+            break
+    return assignment
+
+
+def get_func_rdr_model_path(func: Callable, model_dir: str) -> str:
+    """
+    :param func: The function to get the model path for.
+    :param model_dir: The directory to save the model to.
+    :return: The path to the model file.
+    """
+    func_name = get_method_name(func)
+    func_class_name = get_method_class_name_if_exists(func)
+    func_file_name = get_method_file_name(func)
+    model_name = func_file_name
+    model_name += f"_{func_class_name}" if func_class_name else ""
+    model_name += f"_{func_name}"
+    return os.path.join(model_dir, f"{model_name}.json")
+
+
+def get_method_args_as_dict(method: Callable, *args, **kwargs) -> Dict[str, Any]:
+    """
+    Get the arguments of a method as a dictionary.
+
+    :param method: The method to get the arguments from.
+    :param args: The positional arguments.
+    :param kwargs: The keyword arguments.
+    :return: A dictionary of the arguments.
+    """
+    func_arg_names = method.__code__.co_varnames
+    func_arg_values = args + tuple(kwargs.values())
+    return dict(zip(func_arg_names, func_arg_values))
+
+
+def get_method_name(method: Callable) -> str:
+    """
+    Get the name of a method.
+
+    :param method: The method to get the name of.
+    :return: The name of the method.
+    """
+    return method.__name__ if hasattr(method, "__name__") else str(method)
+
+
+def get_method_class_name_if_exists(method: Callable) -> Optional[str]:
+    """
+    Get the class name of a method if it has one.
+
+    :param method: The method to get the class name of.
+    :return: The class name of the method.
+    """
+    if hasattr(method, "__self__") and hasattr(method.__self__, "__class__"):
+        return method.__self__.__class__.__name__
+    return None
+
+
+def get_method_file_name(method: Callable) -> str:
+    """
+    Get the file name of a method.
+
+    :param method: The method to get the file name of.
+    :return: The file name of the method.
+    """
+    return method.__code__.co_filename
+
+
 def flatten_list(a: List):
     a_flattened = []
     for c in a:
@@ -86,7 +244,7 @@ def recursive_subclasses(cls):
 
 class SubclassJSONSerializer:
     """
-    Copied from: https://github.com/tomsch420/random-events/blob/master/src/random_events/utils.py#L6C1-L21C101
+    Originally from: https://github.com/tomsch420/random-events/blob/master/src/random_events/utils.py#L6C1-L21C101
     Class for automatic (de)serialization of subclasses.
     Classes that inherit from this class can be serialized and deserialized automatically by calling this classes
     'from_json' method.
@@ -150,8 +308,14 @@ class SubclassJSONSerializer:
             return None
         if not isinstance(data, dict) or ('_type' not in data):
             return data
+        if '__dataclass__' in data:
+            # if the data is a dataclass, deserialize it
+            return deserialize_dataclass(data)
+
         # check if type module is builtins
         data_type = get_type_from_string(data["_type"])
+        if len(data) == 1:
+            return data_type
         if data_type.__module__ == 'builtins':
             if is_iterable(data['value']) and not isinstance(data['value'], dict):
                 return data_type([cls.from_json(d) for d in data['value']])
@@ -279,7 +443,7 @@ def table_rows_as_str(row_dict: Dict[str, Any], columns_per_row: int = 9):
     values = [list(map(lambda i: i[1], row)) for row in all_items]
     all_table_rows = []
     for row_keys, row_values in zip(keys, values):
-        table = tabulate([row_values], headers=row_keys, tablefmt='plain')
+        table = tabulate([row_values], headers=row_keys, tablefmt='plain', maxcolwidths=[20] * len(row_keys))
         all_table_rows.append(table)
     return "\n".join(all_table_rows)
 

{ripple_down_rules-0.0.15.dist-info → ripple_down_rules-0.1.1.dist-info}/METADATA

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

@@ -0,0 +1,20 @@
+ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/datasets.py,sha256=AzPtqUXuR1qLQNtRsWLsJ3gX2oIf8nIkFvmsmz7fHlw,4601
+ripple_down_rules/experts.py,sha256=Xz1U1Tdq7jrFlcVuSusaMB241AG9TEs7q101i59Xijs,10683
+ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
+ripple_down_rules/helpers.py,sha256=AhqerAQoCdSovJ7SdQrNtAI_hYagKpLsy2nJQGA0bl0,1062
+ripple_down_rules/prompt.py,sha256=z6KddZOsNiStptgCRNh2OVHHuH6Ooa2f-nsrgJH1qJ8,6311
+ripple_down_rules/rdr.py,sha256=vuRGyqB2wasAzSUhj9HenBp0nC-C1zCGUj3e_th2X7A,43511
+ripple_down_rules/rdr_decorators.py,sha256=8SclpceI3EtrsbuukWJu8HGLh7Q1ZCgYGLX-RPlG-w0,2018
+ripple_down_rules/rules.py,sha256=aM3Im4ePuFDlkuD2EKRtiVmYgoQ_sxlwcbzrDKqXAfs,14578
+ripple_down_rules/utils.py,sha256=9gPnRWlLye7FettI2QRWJx8oU9z3ckwdO5jopXK8b-8,24290
+ripple_down_rules/datastructures/__init__.py,sha256=zpmiYm4WkwNHaGdTIfacS7llN5d2xyU6U-saH_TpydI,103
+ripple_down_rules/datastructures/callable_expression.py,sha256=ac2TaMr0hiRX928GMcr3oTQic8KXXO4syLw4KV-Iehs,10515
+ripple_down_rules/datastructures/case.py,sha256=3Pl07jmYn94wdCVTaRZDmBPgyAsN1TjebvrE6-68MVU,13606
+ripple_down_rules/datastructures/dataclasses.py,sha256=AI-wqNy8y9QPg6lov0P-c5b8JXemuM4X62tIRhW-Gqs,4231
+ripple_down_rules/datastructures/enums.py,sha256=l0Eu-TeJ6qB2XHoJycXmUgLw-3yUebQ8SsEbW8bBZdM,4543
+ripple_down_rules-0.1.1.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.1.1.dist-info/METADATA,sha256=rzAQLYJ7yFFBy9Nthw1qwhhwbOZtv1aTNnNSVyf9BQE,42518
+ripple_down_rules-0.1.1.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+ripple_down_rules-0.1.1.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.1.1.dist-info/RECORD,,

{ripple_down_rules-0.0.15.dist-info → ripple_down_rules-0.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ripple_down_rules-0.0.15.dist-info/RECORD

@@ -1,18 +0,0 @@
-ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules/datasets.py,sha256=qYX7IF7ACm0VRbaKfEgQ32j0YbUUyt2GfGU5Lo42CqI,4601
-ripple_down_rules/experts.py,sha256=wg1uY0ox9dUMR4s1RdGjzpX1_WUqnCa060r1U9lrKYI,11214
-ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
-ripple_down_rules/prompt.py,sha256=QAmxg4ssrGUAlK7lbyKw2nuRczTZColpjc9uMC1ts3I,4210
-ripple_down_rules/rdr.py,sha256=am57_cmN2ge_eKGQLIAyd5iH4iSC15QrFHmdmwwM_uY,41947
-ripple_down_rules/rules.py,sha256=MUZv42WPOB73rzw6Um2F_q0woRFG4db4yYB6R-qMpKA,14239
-ripple_down_rules/utils.py,sha256=32gU9NHIcxQpfS4zPSAtn63np5SdVvS9VuyoYiyKZbc,18664
-ripple_down_rules/datastructures/__init__.py,sha256=zpmiYm4WkwNHaGdTIfacS7llN5d2xyU6U-saH_TpydI,103
-ripple_down_rules/datastructures/callable_expression.py,sha256=TN6bi4VYjyLlSLTEA3dRo5ENfEdQYc8Fjj5nbnsz-C0,9058
-ripple_down_rules/datastructures/case.py,sha256=0EV69VBzsBTHQ3Ots7fkP09g1tyJ20xW9kSm0nZGy40,14071
-ripple_down_rules/datastructures/dataclasses.py,sha256=EVQ1jBKW7K7q7_JNgikHX9fm3EmQQKA74sNjEQ4rXn8,2449
-ripple_down_rules/datastructures/enums.py,sha256=l0Eu-TeJ6qB2XHoJycXmUgLw-3yUebQ8SsEbW8bBZdM,4543
-ripple_down_rules-0.0.15.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.0.15.dist-info/METADATA,sha256=JOCvhnY9h7adkNGnR9uX0j_d7oQcIIBTY8kCpZ2VsD4,42519
-ripple_down_rules-0.0.15.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ripple_down_rules-0.0.15.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.0.15.dist-info/RECORD,,