ripple-down-rules 0.0.0__py3-none-any.whl

ripple_down_rules/utils.py

@@ -0,0 +1,463 @@
+from __future__ import annotations
+
+import logging
+from abc import abstractmethod
+from collections import UserDict
+from copy import deepcopy
+from dataclasses import dataclass
+
+import matplotlib
+import networkx as nx
+from anytree import Node, RenderTree
+from anytree.exporter import DotExporter
+from matplotlib import pyplot as plt
+from sqlalchemy import MetaData, inspect
+from sqlalchemy.orm import Mapped, registry, class_mapper, DeclarativeBase as SQLTable, Session
+from tabulate import tabulate
+from typing_extensions import Callable, Set, Any, Type, Dict, TYPE_CHECKING, get_type_hints, \
+    get_origin, get_args, Tuple, Optional, List, Union, Self
+
+if TYPE_CHECKING:
+    from .datastructures import Case
+
+matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
+
+
+def get_full_class_name(cls):
+    """
+    Returns the full name of a class, including the module name.
+    Copied from: https://github.com/tomsch420/random-events/blob/master/src/random_events/utils.py#L6C1-L21C101
+
+    :param cls: The class.
+    :return: The full name of the class
+    """
+    return cls.__module__ + "." + cls.__name__
+
+
+def recursive_subclasses(cls):
+    """
+    Copied from: https://github.com/tomsch420/random-events/blob/master/src/random_events/utils.py#L6C1-L21C101
+    :param cls: The class.
+    :return: A list of the classes subclasses.
+    """
+    return cls.__subclasses__() + [g for s in cls.__subclasses__() for g in recursive_subclasses(s)]
+
+
+class SubclassJSONSerializer:
+    """
+    Copied 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.
+    """
+
+    def to_json(self) -> Dict[str, Any]:
+        return {"_type": get_full_class_name(self.__class__)}
+
+    @classmethod
+    @abstractmethod
+    def _from_json(cls, data: Dict[str, Any]) -> Self:
+        """
+        Create a variable from a json dict.
+        This method is called from the from_json method after the correct subclass is determined and should be
+        overwritten by the respective subclass.
+
+        :param data: The json dict
+        :return: The deserialized object
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    def from_json(cls, data: Dict[str, Any]) -> Self:
+        """
+        Create the correct instanceof the subclass from a json dict.
+
+        :param data: The json dict
+        :return: The correct instance of the subclass
+        """
+        for subclass in recursive_subclasses(SubclassJSONSerializer):
+            if get_full_class_name(subclass) == data["_type"]:
+                return subclass._from_json(data)
+
+        raise ValueError("Unknown type {}".format(data["_type"]))
+
+
+def copy_case(case: Union[Case, SQLTable]) -> Union[Case, SQLTable]:
+    """
+    Copy a case.
+
+    :param case: The case to copy.
+    :return: The copied case.
+    """
+    if isinstance(case, SQLTable):
+        return copy_orm_instance_with_relationships(case)
+    else:
+        return deepcopy(case)
+
+
+def copy_orm_instance(instance: SQLTable) -> SQLTable:
+    """
+    Copy an ORM instance by expunging it from the session then deep copying it and adding it back to the session. This
+    is useful when you want to copy an instance and make changes to it without affecting the original instance.
+
+    :param instance: The instance to copy.
+    :return: The copied instance.
+    """
+    session: Session = inspect(instance).session
+    session.expunge(instance)
+    new_instance = deepcopy(instance)
+    session.add(instance)
+    return new_instance
+
+
+def copy_orm_instance_with_relationships(instance: SQLTable) -> SQLTable:
+    """
+    Copy an ORM instance with its relationships (i.e. its foreign keys).
+
+    :param instance: The instance to copy.
+    :return: The copied instance.
+    """
+    instance_cp = copy_orm_instance(instance)
+    for rel in class_mapper(instance.__class__).relationships:
+        related_obj = getattr(instance, rel.key)
+        if related_obj is not None:
+            setattr(instance_cp, rel.key, related_obj)
+    return instance_cp
+
+
+def get_value_type_from_type_hint(attr_name: str, obj: Any) -> Type:
+    """
+    Get the value type from the type hint of an object attribute.
+
+    :param attr_name: The name of the attribute.
+    :param obj: The object to get the attributes from.
+    """
+    hint, origin, args = get_hint_for_attribute(attr_name, obj)
+    if not origin and not hint:
+        if hasattr(obj, attr_name):
+            attr_value = getattr(obj, attr_name)
+            if attr_value is not None:
+                return type(attr_value)
+        raise ValueError(f"Couldn't get type for Attribute {attr_name}, please provide a type hint")
+    if origin in [list, set, tuple, type, dict]:
+        attr_value_type = args[0]
+    elif hint:
+        attr_value_type = hint
+    else:
+        raise ValueError(f"Attribute {attr_name} has unsupported type {hint}.")
+    return attr_value_type
+
+
+def get_hint_for_attribute(attr_name: str, obj: Any) -> Tuple[Optional[Any], Optional[Any], Tuple[Any]]:
+    """
+    Get the type hint for an attribute of an object.
+
+    :param attr_name: The name of the attribute.
+    :param obj: The object to get the attribute from.
+    :return: The type hint of the attribute.
+    """
+    if attr_name is None or not hasattr(obj.__class__, attr_name):
+        return None, None, ()
+    class_attr = getattr(obj.__class__, attr_name)
+    if isinstance(class_attr, property):
+        if not class_attr.fget:
+            raise ValueError(f"Attribute {attr_name} has no getter.")
+        hint = get_type_hints(class_attr.fget)['return']
+    else:
+        try:
+            hint = get_type_hints(obj.__class__)[attr_name]
+        except KeyError:
+            hint = type(class_attr)
+    origin = get_origin(hint)
+    args = get_args(hint)
+    if origin is Mapped:
+        return args[0], get_origin(args[0]), get_args(args[0])
+    else:
+        return hint, origin, args
+
+
+def table_rows_as_str(row_dict: Dict[str, Any], columns_per_row: int = 9):
+    """
+    Print a table row.
+
+    :param row_dict: The row to print.
+    :param columns_per_row: The maximum number of columns per row.
+    """
+    all_items = list(row_dict.items())
+    # make items a list of n rows such that each row has a max size of 4
+    all_items = [all_items[i:i + columns_per_row] for i in range(0, len(all_items), columns_per_row)]
+    keys = [list(map(lambda i: i[0], row)) for row in all_items]
+    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')
+        all_table_rows.append(table)
+    return "\n".join(all_table_rows)
+
+
+def row_to_dict(obj):
+    return {
+        col.name: getattr(obj, col.name)
+        for col in obj.__table__.columns
+        if not col.primary_key and not col.foreign_keys
+    }
+
+
+def get_attribute_name(obj: Any, attribute: Optional[Any] = None, attribute_type: Optional[Type] = None,
+                       possible_value: Optional[Any] = None) -> Optional[str]:
+    """
+    Get the name of an attribute from an object. The attribute can be given as a value, a type or a target value.
+    And this method will try to find the attribute name using the given information.
+
+    :param obj: The object to get the attribute name from.
+    :param attribute: The attribute to get the name of.
+    :param attribute_type: The type of the attribute to get the name of.
+    :param possible_value: A possible value of the attribute to get the name of.
+    :return: The name of the attribute.
+    """
+    attribute_name: Optional[str] = None
+    if attribute_name is None and attribute is not None:
+        attribute_name = get_attribute_name_from_value(obj, attribute)
+    if attribute_name is None and attribute_type is not None:
+        attribute_name = get_attribute_by_type(obj, attribute_type)[0]
+    if attribute_name is None and possible_value is not None:
+        attribute_name = get_attribute_by_type(obj, type(possible_value))[0]
+    return attribute_name
+
+
+def get_attribute_by_type(obj: Any, prop_type: Type) -> Tuple[Optional[str], Optional[Any]]:
+    """
+    Get a property from an object by type.
+
+    :param obj: The object to get the property from.
+    :param prop_type: The type of the property.
+    """
+    for name in dir(obj):
+        if name.startswith("_") or callable(getattr(obj, name)):
+            continue
+        if isinstance(getattr(obj, name), (MetaData, registry)):
+            continue
+        prop_value = getattr(obj, name)
+        if isinstance(prop_value, prop_type):
+            return name, prop_value
+        if hasattr(prop_value, "__iter__") and not isinstance(prop_value, str):
+            if len(prop_value) > 0 and any(isinstance(v, prop_type) for v in prop_value):
+                return name, prop_value
+            else:
+                # get args of type hint
+                hint, origin, args = get_hint_for_attribute(name, obj)
+                if origin in [list, set, tuple, dict, List, Set, Tuple, Dict]:
+                    if prop_type is args[0]:
+                        return name, prop_value
+        else:
+            # get the type hint of the attribute
+            hint, origin, args = get_hint_for_attribute(name, obj)
+            if hint is prop_type:
+                return name, prop_value
+            elif origin in [list, set, tuple, dict, List, Set, Tuple, Dict]:
+                if prop_type is args[0]:
+                    return name, prop_value
+    return None, None
+
+
+def get_attribute_name_from_value(obj: Any, attribute_value: Any) -> Optional[str]:
+    """
+    Get the name of an attribute from an object.
+
+    :param obj: The object to get the attribute name from.
+    :param attribute_value: The attribute value to get the name of.
+    """
+    for name in dir(obj):
+        if name.startswith("_") or callable(getattr(obj, name)):
+            continue
+        prop_value = getattr(obj, name)
+        if prop_value is attribute_value:
+            return name
+
+
+def get_attribute_values_transitively(obj: Any, attribute: Any) -> Any:
+    """
+    Get an attribute from a python object, if it is iterable, get the attribute values from all elements and unpack them
+    into a list.
+
+    :param obj: The object to get the sub attribute from.
+    :param attribute: The  attribute to get.
+    """
+    if hasattr(obj, "__iter__") and not isinstance(obj, str):
+        if isinstance(obj, (dict, UserDict)):
+            all_values = [get_attribute_values_transitively(v, attribute) for v in obj.values()
+                          if not isinstance(v, (str, type)) and hasattr(v, attribute)]
+        else:
+            all_values = [get_attribute_values_transitively(a, attribute) for a in obj
+                          if not isinstance(a, (str, type)) and hasattr(a, attribute)]
+        if can_be_a_set(all_values):
+            return set().union(*all_values)
+        else:
+            return set(all_values)
+    return getattr(obj, attribute)
+
+
+def can_be_a_set(value: Any) -> bool:
+    """
+    Check if a value can be a set.
+
+    :param value: The value to check.
+    """
+    if hasattr(value, "__iter__") and not isinstance(value, str):
+        if len(value) > 0 and any(hasattr(v, "__iter__") and not isinstance(v, str) for v in value):
+            return False
+        else:
+            return True
+    else:
+        return False
+
+
+def get_all_subclasses(cls: Type) -> Dict[str, Type]:
+    """
+    Get all subclasses of a class recursively.
+
+    :param cls: The class to get the subclasses of.
+    :return: A dictionary of all subclasses.
+    """
+    all_subclasses: Dict[str, Type] = {}
+    for sub_cls in cls.__subclasses__():
+        all_subclasses[sub_cls.__name__.lower()] = sub_cls
+        all_subclasses.update(get_all_subclasses(sub_cls))
+    return all_subclasses
+
+
+def make_set(value: Any) -> Set:
+    """
+    Make a set from a value.
+
+    :param value: The value to make a set from.
+    """
+    if hasattr(value, "__iter__") and not isinstance(value, (str, type)):
+        return set(value)
+    return {value}
+
+
+def make_list(value: Any) -> List:
+    """
+    Make a list from a value.
+
+    :param value: The value to make a list from.
+    """
+    if hasattr(value, "__iter__") and not isinstance(value, (str, type)):
+        return list(value)
+    return [value]
+
+
+def make_value_or_raise_error(value: Any) -> Any:
+    """
+    Make a value or raise an error if the value is not a single value.
+
+    :param value: The value to check.
+    """
+    if hasattr(value, "__iter__") and not isinstance(value, str):
+        if hasattr(value, "__len__") and len(value) == 1:
+            return list(value)[0]
+        else:
+            raise ValueError(f"Expected a single value, got {value}")
+    return value
+
+
+def tree_to_graph(root_node: Node) -> nx.DiGraph:
+    """
+    Convert anytree to a networkx graph.
+
+    :param root_node: The root node of the tree.
+    :return: A networkx graph.
+    """
+    graph = nx.DiGraph()
+    unique_node_names = get_unique_node_names_func(root_node)
+
+    def add_edges(node):
+        if unique_node_names(node) not in graph.nodes:
+            graph.add_node(unique_node_names(node))
+        for child in node.children:
+            if unique_node_names(child) not in graph.nodes:
+                graph.add_node(unique_node_names(child))
+            graph.add_edge(unique_node_names(node), unique_node_names(child), weight=child.weight)
+            add_edges(child)
+
+    add_edges(root_node)
+    return graph
+
+
+def get_unique_node_names_func(root_node) -> Callable[[Node], str]:
+    nodes = [root_node]
+
+    def get_all_nodes(node):
+        for c in node.children:
+            nodes.append(c)
+            get_all_nodes(c)
+
+    get_all_nodes(root_node)
+
+    def nodenamefunc(node: Node):
+        """
+        Set the node name for the dot exporter.
+        """
+        similar_nodes = [n for n in nodes if n.name == node.name]
+        node_idx = similar_nodes.index(node)
+        return node.name if node_idx == 0 else f"{node.name}_{node_idx}"
+
+    return nodenamefunc
+
+
+def edge_attr_setter(parent, child):
+    """
+    Set the edge attributes for the dot exporter.
+    """
+    if child and hasattr(child, "weight") and child.weight:
+        return f'style="bold", label=" {child.weight}"'
+    return ""
+
+
+def render_tree(root: Node, use_dot_exporter: bool = False,
+                filename: str = "scrdr"):
+    """
+    Render the tree using the console and optionally export it to a dot file.
+
+    :param root: The root node of the tree.
+    :param use_dot_exporter: Whether to export the tree to a dot file.
+    :param filename: The name of the file to export the tree to.
+    """
+    if not root:
+        logging.warning("No rules to render")
+        return
+    for pre, _, node in RenderTree(root):
+        print(f"{pre}{node.weight if hasattr(node, 'weight') and node.weight else ''} {node.__str__()}")
+    if use_dot_exporter:
+        unique_node_names = get_unique_node_names_func(root)
+
+        de = DotExporter(root,
+                         nodenamefunc=unique_node_names,
+                         edgeattrfunc=edge_attr_setter
+                         )
+        de.to_dotfile(f"{filename}{'.dot'}")
+        de.to_picture(f"{filename}{'.png'}")
+
+
+def draw_tree(root: Node, fig: plt.Figure):
+    """
+    Draw the tree using matplotlib and networkx.
+    """
+    if root is None:
+        return
+    fig.clf()
+    graph = tree_to_graph(root)
+    fig_sz_x = 13
+    fig_sz_y = 10
+    fig.set_size_inches(fig_sz_x, fig_sz_y)
+    pos = nx.drawing.nx_agraph.graphviz_layout(graph, prog="dot")
+    # scale down pos
+    max_pos_x = max([v[0] for v in pos.values()])
+    max_pos_y = max([v[1] for v in pos.values()])
+    pos = {k: (v[0] * fig_sz_x / max_pos_x, v[1] * fig_sz_y / max_pos_y) for k, v in pos.items()}
+    nx.draw(graph, pos, with_labels=True, node_color="lightblue", edge_color="gray", node_size=1000,
+            ax=fig.gca(), node_shape="o", font_size=8)
+    nx.draw_networkx_edge_labels(graph, pos, edge_labels=nx.get_edge_attributes(graph, 'weight'),
+                                 ax=fig.gca(), rotate=False, clip_on=False)
+    plt.pause(0.1)

ripple_down_rules-0.0.0.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: ripple_down_rules
+Version: 0.0.0
+Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
+Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
+Project-URL: Homepage, https://github.com/AbdelrhmanBassiouny/ripple_down_rules
+Keywords: robotics,knowledge,reasoning,representation
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: neem_pycram_interface==1.0.167
+
+# Ripple Down Rules (RDR)
+
+A python implementation of the various ripple down rules versions, including Single Classification (SCRDR),
+Multi Classification (MCRDR), and Generalised Ripple Down Rules (GRDR).
+
+SCRDR, MCRDR, and GRDR are rule-based classifiers that are built incrementally, and can be used to classify
+data cases. The rules are refined as new data cases are classified.
+
+SCRDR, MCRDR, and GRDR implementation were inspired from the book:
+["Ripple Down Rules: An Alternative to Machine Learning"](https://doi.org/10.1201/9781003126157) by Paul Compton, Byeong Ho Kang.
+
+## Installation
+
+```bash
+sudo apt-get install graphviz graphviz-dev
+pip install ripple_down_rules
+```
+
+## Example Usage
+
+Fit the SCRDR to the data, then classify one of the data cases to check if its correct,
+and render the tree to a file:
+
+```Python
+from ripple_down_rules.rdr import SingleClassRDR
+from ripple_down_rules.datasets import load_zoo_dataset
+from ripple_down_rules.utils import render_tree
+
+all_cases, targets = load_zoo_dataset()
+
+scrdr = SingleClassRDR()
+
+# Fit the SCRDR to the data
+scrdr.fit(all_cases, targets,
+          animate_tree=True, n_iter=10)
+
+# Render the tree to a file
+render_tree(scrdr.start_rule, use_dot_exporter=True, filename="scrdr")
+
+cat = scrdr.fit_case(all_cases[50], targets[50])
+assert cat == targets[50]
+```

ripple_down_rules-0.0.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/datasets.py,sha256=meZ2zpDkA3v_Hnat6r01bzWQi9eQMp6Qv0ESXyB8aTc,4214
+ripple_down_rules/experts.py,sha256=wss-rMjmVRNoNpPNo_EygNsh57iebNi-g2j7_SkgWIU,11636
+ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
+ripple_down_rules/prompt.py,sha256=lmREZRyleBTHrVtcf2j_48oc0v3VlxXYGhl6w1mk8qI,4208
+ripple_down_rules/rdr.py,sha256=AGfUmfuTmxMd3M7wTCXJpK_mK1Tuhzsqg088Q3Kr9Cs,33059
+ripple_down_rules/rules.py,sha256=H4Zm_9YN91GxttrgcUcpeLBPrU68oijqMVnON1uOxyY,10252
+ripple_down_rules/utils.py,sha256=DgGJ0wzYkMlNbUfuLLpS_uynyJMJId4cc3m1DkZgGas,16345
+ripple_down_rules/datastructures/__init__.py,sha256=wY9WqXavuE3wQ1YP65cs_SZyr7CEMB9tol-4oxgK9CM,104
+ripple_down_rules/datastructures/callable_expression.py,sha256=QscF3nvVrZhH6dgAFO29_UGjcHprDV2wgjdeDXNYLUw,9066
+ripple_down_rules/datastructures/dataclasses.py,sha256=z_9B7Nj_MIf2Iyrs5VeUhXhYxwaqnuKVjgwxhZZTygY,2525
+ripple_down_rules/datastructures/enums.py,sha256=6Mh55_8QRuXyYZXtonWr01VBgLP-jYp91K_8hIgh8u8,4244
+ripple_down_rules/datastructures/table.py,sha256=PffU8_NUY9q-lzvU9-L4cVI0hvJPFkX1uRpMq3zlq5M,22902
+ripple_down_rules/datastructures/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/datastructures/generated/column/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/datastructures/generated/row/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules-0.0.0.dist-info/METADATA,sha256=8uBKAK8WCDkSrP_d9wqbEX0A2vr8WgTUwdudGVBYaQA,1858
+ripple_down_rules-0.0.0.dist-info/WHEEL,sha256=DK49LOLCYiurdXXOXwGJm6U4DkHkg4lcxjhqwRa0CP4,91
+ripple_down_rules-0.0.0.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.0.0.dist-info/RECORD,,

ripple_down_rules-0.0.0.dist-info/WHEEL

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

ripple_down_rules-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ripple_down_rules