IMoTE 0.0.0__py3-none-any.whl

imote/__init__.py

@@ -0,0 +1,28 @@
+"""IMoTE: Interactive MOdel Tree Explorer."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("imote")  # set from the git tag by setuptools-scm at install time
+except PackageNotFoundError:  # running from a source tree that was never pip installed
+    __version__ = "0+unknown"
+
+from imote.adapters import M5Adapter, PartyKitAdapter, PilotAdapter
+from imote.adapters.base_adapter import ADAPTERS_REGISTRY, BaseAdapter, register_adapter
+from imote.dataset.dataset import Dataset
+from imote.node_metrics.node_metric import NODE_METRICS_REGISTRY, BaseNodeMetric, register_metric
+from imote.viz_tree.viz_tree import VizTree
+
+__all__ = [
+    "VizTree",
+    "Dataset",
+    "BaseAdapter",
+    "register_adapter",
+    "ADAPTERS_REGISTRY",
+    "PilotAdapter",
+    "M5Adapter",
+    "PartyKitAdapter",
+    "BaseNodeMetric",
+    "register_metric",
+    "NODE_METRICS_REGISTRY",
+]

imote/adapters/__init__.py

@@ -0,0 +1,3 @@
+from .pilot_adapter import PilotAdapter
+from .m5_adapter import M5Adapter
+from .partykit_adapter import PartyKitAdapter

imote/adapters/adapter_utils.py

@@ -0,0 +1,15 @@
+import numpy as np
+
+def split_by_threshold(X_train, current_indices, pivot_idx, pivot_value):
+    mask = X_train[current_indices, pivot_idx] <= pivot_value
+    return _apply_mask(current_indices, mask)
+
+def split_by_categories(X_train, current_indices, pivot_idx, left_categories):
+    mask = np.isin(X_train[current_indices, pivot_idx], left_categories)
+    return _apply_mask(current_indices, mask)
+
+def _apply_mask(current_indices, mask):
+    left_indices, right_indices = current_indices.copy(), current_indices.copy()
+    left_indices[current_indices] = mask
+    right_indices[current_indices] = ~mask
+    return left_indices, right_indices

imote/adapters/base_adapter.py

@@ -0,0 +1,76 @@
+from abc import ABC, abstractmethod
+import numpy as np
+from imote.nodes.base_node import BaseNode
+
+ADAPTERS_REGISTRY: dict[str, type["BaseAdapter"]] = {}
+"""Maps adapter names to adapter classes, populated via register_adapter()."""
+
+def register_adapter(name: str):
+    """Class decorator that registers an adapter under a given name.
+
+    Args:
+        name: Name to register the adapter under.
+
+    Returns:
+        A decorator that registers the decorated class and returns it
+        unchanged.
+    """
+    def decorator(adapter_cls):
+        ADAPTERS_REGISTRY[name] = adapter_cls
+        return adapter_cls
+    return decorator
+
+class BaseAdapter(ABC):
+    """Abstract base class for adapters that build a VizTree from a model.
+
+    An adapter translates a fitted model from a specific source
+    into the BaseNode linked tree structure that VizTree expects.
+    """
+
+    @staticmethod
+    @abstractmethod
+    def build_root_node(X_train: np.ndarray, y_train: np.ndarray, model) -> BaseNode:
+        """Builds the BaseNode linked tree representing a fitted model.
+
+        Args:
+            X_train: Training feature matrix the model was fit on.
+            y_train: Training target values the model was fit on.
+            model: The fitted model, in whatever format this adapter
+                supports (as returned by load_model()).
+
+        Returns:
+            Root BaseNode of the reconstructed linked tree.
+        """
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def load_model(model_path: str):
+        """Loads a fitted model from disk.
+
+        Args:
+            model_path: Path to the serialized model file.
+
+        Returns:
+            The loaded model, in the format this adapter's
+            build_root_node() expects.
+        """
+        pass
+
+    @staticmethod
+    def predict(X: np.ndarray, model) -> np.ndarray | None:
+        """Predicts target values directly from the underlying model, if possible.
+
+        This is optional: an adapter can override it to use the
+        original model's own prediction logic (e.g. for speed or
+        numerical parity). If not overridden, VizTree instead computes
+        predictions by traversing the built BaseNode linked tree.
+
+        Args:
+            X: Feature matrix to predict on.
+            model: The fitted model, as returned by load_model().
+
+        Returns:
+            Array of predicted values, or None if not implemented.
+        """
+        return None

imote/adapters/build_root_node_m5.py

@@ -0,0 +1,71 @@
+import numpy as np
+from m5py.main import ConstantLeafModel, LinRegLeafModel
+
+from imote.adapters.adapter_utils import split_by_threshold
+from imote.nodes.base_node import BaseNode
+from imote.nodes.leaf_node import LeafNode
+from imote.nodes.split_node import SplitNode
+from imote.nodes.node_model import LinearNodeModel, NoneNodeModel, ConstantNodeModel
+
+def build_root_node_from_m5(m5_model, X_train, y_train) -> BaseNode:
+    # builds a viz tree from a fitted m5py model (M5Base / M5Prime).
+    tree = m5_model.tree_
+    node_models = m5_model.node_models
+    root_indices = np.ones(X_train.shape[0], dtype=bool)
+
+    return _build_root_node_from_m5(tree, node_models, X_train, y_train, root_indices, node_id=0)
+
+def _build_root_node_from_m5(tree, node_models, X_train, y_train, current_indices, node_id) -> BaseNode:
+
+    current_y_res = y_train[current_indices]
+    n_features = X_train.shape[1]
+
+    left_id = tree.children_left[node_id]
+    right_id = tree.children_right[node_id]
+
+    if left_id == -1:  # sklearn's TREE_LEAF sentinel; children_left/right are both -1 at leaves
+        model = node_models[node_id]
+
+        if isinstance(model, ConstantLeafModel):
+            rss = model.error  # note: this is an RMSE, not a raw RSS like PILOT's Rt - rescale/rename if needed
+            node_model = ConstantNodeModel(float(tree.value[node_id].ravel()[0]))
+
+        elif isinstance(model, LinRegLeafModel):
+            coefficients = np.zeros(n_features)
+            coefficients[model.features] = model.model.coef_
+            intercept = model.model.intercept_
+            rss = model.error  # same caveat as above
+            node_model = LinearNodeModel(coefficients, intercept)
+
+        else:
+            raise ValueError(f"Unexpected leaf model type: {type(model)}")
+
+        return LeafNode(
+            indices=current_indices,
+            y_res=current_y_res,
+            rss=rss,
+            node_model=node_model,
+        )
+
+    else:
+        pivot_idx = tree.feature[node_id]
+        pivot_value = tree.threshold[node_id]
+
+        left_indices, right_indices = split_by_threshold(X_train, current_indices, pivot_idx, pivot_value)
+
+        left_child = _build_root_node_from_m5(tree, node_models, X_train, y_train, left_indices, node_id=left_id)
+        right_child = _build_root_node_from_m5(tree, node_models, X_train, y_train, right_indices, node_id=right_id)
+
+        rss = tree.impurity[node_id] * tree.n_node_samples[node_id]  # sklearn stores impurity as MSE; * n -> RSS
+
+        return SplitNode(
+            indices=current_indices,
+            y_res=current_y_res,
+            rss=rss,
+            pivot_idx=pivot_idx,
+            pivot_value=pivot_value,
+            left_child=left_child,
+            right_child=right_child,
+            left_model=NoneNodeModel(),
+            right_model=NoneNodeModel(),
+        )

imote/adapters/m5_adapter.py

@@ -0,0 +1,18 @@
+import numpy as np
+from imote.nodes.base_node import BaseNode
+from .build_root_node_m5 import build_root_node_from_m5
+from .base_adapter import BaseAdapter, register_adapter
+
+@register_adapter("M5")
+class M5Adapter(BaseAdapter):
+    @staticmethod
+    def build_root_node(X_train, y_train, model) -> BaseNode:
+        return build_root_node_from_m5(model, X_train, y_train)
+
+    @staticmethod
+    def load_model(model_path):
+        raise NotImplementedError()
+
+    @staticmethod
+    def predict(X, m5_model) -> np.ndarray:
+        return m5_model.predict(X)

imote/adapters/partykit_adapter.py

@@ -0,0 +1,133 @@
+import os
+import json
+import numpy as np
+from imote.adapters.base_adapter import BaseAdapter, register_adapter
+from imote.adapters.adapter_utils import split_by_categories, split_by_threshold
+from imote.nodes.base_node import BaseNode
+from imote.nodes.leaf_node import LeafNode
+from imote.nodes.split_node import SplitNode, SplitCNode
+from imote.nodes.node_model import LinearNodeModel, NoneNodeModel
+
+@register_adapter('Partykit')
+class PartyKitAdapter(BaseAdapter):
+    """Adapter that builds a BaseNode linked tree from an R `partykit` package model export."""
+
+    @staticmethod
+    def load_model(model_path: str) -> dict:
+        """Loads a partykit model export from a JSON file.
+
+        Args:
+            model_path: Path to the JSON file containing the exported
+                partykit model.
+
+        Returns:
+            The parsed model as a dict.
+
+        Raises:
+            FileNotFoundError: If model_path does not exist.
+        """
+        if not os.path.exists(model_path):
+            raise FileNotFoundError(f"No such file path to load model: {model_path}")  # The standard exception for a missing file
+        with open(model_path) as f:
+            model = json.load(f)
+
+        return model
+
+    @staticmethod
+    def build_root_node(X_train: np.ndarray, y_train: np.ndarray, model) -> BaseNode:
+        """Builds the BaseNode linked tree representing a partykit model.
+
+        Args:
+            X_train: Training feature matrix the model was fit on.
+            y_train: Training target values the model was fit on.
+            model: Parsed partykit model, as returned by load_model().
+
+        Returns:
+            Root BaseNode of the reconstructed tree.
+        """
+        root_indices = np.ones(X_train.shape[0], dtype=bool)
+        node_list = model['nodes']
+        feature_names = model['names'][1:]
+        return PartyKitAdapter._build_recursive(node_list, feature_names, node_list[0], X_train, y_train, root_indices)
+
+    @staticmethod
+    def _build_recursive(node_list, feature_names, node, X_train, y_train, current_indices) -> BaseNode:
+        """Recursively builds a BaseNode (sub)tree from partykit node data.
+
+        Args:
+            node_list: Full flat list of partykit node dicts for the model.
+            feature_names: Feature names, in the same column order as X_train.
+            node: The partykit node dict to convert at this recursion step.
+            X_train: Training feature matrix the model was fit on.
+            y_train: Training target values the model was fit on.
+            current_indices: Boolean mask over X_train's rows selecting
+                the samples that reach this node.
+
+        Returns:
+            A BaseNode linked (sub)tree.
+
+        Raises:
+            ValueError: If node has neither a "breaks" nor an "index"
+                key, so its split type can't be determined.
+        """
+        current_y_res = y_train[current_indices]
+
+        if node["is_terminal"]:
+            coefficients = np.array([
+                node["coefficients"].get(name, 0.0)
+                for name in feature_names
+            ], dtype=float)
+
+            node_model = LinearNodeModel(coefficients, node["coefficients"]['(Intercept)'])
+
+            return LeafNode(
+                indices=current_indices,
+                y_res=current_y_res,
+                rss=-1, #TODO
+                node_model=node_model,
+            )
+        else:
+            pivot_idx = feature_names.index(node["split_var"])
+            left_node = node_list[node["kids"][0]]
+            right_node = node_list[node["kids"][1]]
+            if "breaks" in node:
+                pivot_value = node["breaks"]
+                left_indices, right_indices = split_by_threshold(X_train, current_indices, pivot_idx, pivot_value)
+
+                left_child = PartyKitAdapter._build_recursive(
+                    node_list, feature_names, left_node, X_train, y_train, left_indices)
+                right_child = PartyKitAdapter._build_recursive(
+                    node_list, feature_names, right_node, X_train, y_train, right_indices)
+
+                return SplitNode(
+                    indices=current_indices,
+                    y_res=current_y_res,
+                    rss=-1, #TODO
+                    pivot_idx=pivot_idx,
+                    pivot_value=pivot_value,
+                    left_child=left_child,
+                    right_child=right_child,
+                    left_model=NoneNodeModel(),
+                    right_model=NoneNodeModel(),
+                )
+            elif "index" in node:
+                left_categories = [lvl for lvl, idx in zip(node["levels"], node["index"]) if idx == 1]
+                left_indices, right_indices = split_by_categories(X_train, current_indices, pivot_idx, left_categories)
+
+                left_child = PartyKitAdapter._build_recursive(
+                    node_list, feature_names, left_node, X_train, y_train, left_indices)
+                right_child = PartyKitAdapter._build_recursive(
+                    node_list, feature_names, right_node, X_train, y_train, right_indices)
+                return SplitCNode(
+                    indices=current_indices,
+                    y_res=current_y_res,
+                    rss=-1, #TODO
+                    pivot_idx=pivot_idx,
+                    pivot_value=left_categories,
+                    left_child=left_child,
+                    right_child=right_child,
+                    left_model=NoneNodeModel(),
+                    right_model=NoneNodeModel(),
+                )
+            else:
+                raise ValueError(f"Unknown node: {node}")

imote/adapters/pilot_adapter.py

@@ -0,0 +1,154 @@
+from imote.nodes.base_node import BaseNode
+from imote.nodes.leaf_node import LeafNode
+from imote.nodes.internal_node import LinearNode
+from imote.nodes.split_node import PconNode, BlinNode, PlinNode, PconcNode
+from imote.nodes.node_model import LinearNodeModel, ConstantNodeModel, SimpleLinearNodeModel
+import numpy as np
+from .base_adapter import BaseAdapter, register_adapter
+
+
+@register_adapter("Pilot")
+class PilotAdapter(BaseAdapter):
+    @staticmethod
+    def build_root_node(X_train, y_train, model) -> BaseNode:
+        tree = model.tree_summary()
+        n_features = X_train.shape[1]
+        root_indices = np.ones(X_train.shape[0], dtype=bool)
+        if tree.parent_node_id[0]:
+            raise ValueError('First node is not the root node')
+        return PilotAdapter._build_recursive(
+            tree, 0, X_train, root_indices, y_train,
+            np.zeros(n_features), 0.0,
+        )
+
+    @staticmethod
+    def _build_recursive(tree, node_index, X_train, current_indices, current_y_res,
+                               accumulated_coefficients, accumulated_intercept) -> BaseNode:
+        node_type = tree.node_type[node_index]
+        if node_type == 'con' or node_type == 'END':
+            leaf_intercept = accumulated_intercept + np.nan_to_num(tree.intercept_left[node_index])
+            return LeafNode(
+                indices=current_indices,
+                y_res=current_y_res,
+                rss=float(np.sum(current_y_res ** 2)),
+                node_model=LinearNodeModel(accumulated_coefficients, leaf_intercept),
+            )
+
+        children_index = np.where(tree.parent_node_id == tree.node_id[node_index])[0]
+        if node_type == 'lin':
+            pivot_idx = int(tree.feature_index[node_index])
+            coef = tree.slope_left[node_index]
+            intercept = tree.intercept_left[node_index]
+
+            new_coefficients = accumulated_coefficients.copy()
+            new_coefficients[pivot_idx] += coef
+            new_intercept = accumulated_intercept + intercept
+
+            new_y_res = current_y_res - (intercept + coef * X_train[current_indices, pivot_idx])
+            child_index = children_index[0]
+            child = PilotAdapter._build_recursive(tree, child_index, X_train, current_indices, new_y_res,
+                                                         new_coefficients, new_intercept)
+
+            return LinearNode(
+                indices=current_indices,
+                y_res=current_y_res,
+                rss=float(np.sum(current_y_res ** 2)),
+                pivot_idx=pivot_idx,
+                linear_model=SimpleLinearNodeModel(pivot_idx, coef, intercept),
+                child=child,
+            )
+        elif node_type in ['pcon', 'pconc', 'blin', 'plin']:
+            pivot_idx = int(tree.feature_index[node_index])
+            coef_left = np.nan_to_num(tree.slope_left[node_index])
+            intercept_left = np.nan_to_num(tree.intercept_left[node_index])
+            coef_right = np.nan_to_num(tree.slope_right[node_index])
+            intercept_right = np.nan_to_num(tree.intercept_right[node_index])
+
+            if node_type == 'pconc':
+                pivot_value = tree.pivot_values[node_index]
+                left_mask = np.isin(X_train[current_indices, pivot_idx], pivot_value)
+                right_mask = ~left_mask
+            else:
+                pivot_value = tree.split_value[node_index]
+                left_mask = X_train[current_indices, pivot_idx] <= pivot_value
+                right_mask = ~left_mask
+            left_indices, right_indices = current_indices.copy(), current_indices.copy()
+            left_indices[current_indices] = left_mask
+            right_indices[current_indices] = right_mask
+
+            left_y_res = current_y_res[left_mask] - (intercept_left + coef_left * X_train[left_indices, pivot_idx])
+            left_coefficients = accumulated_coefficients.copy()
+            left_coefficients[pivot_idx] += coef_left
+            left_intercept = accumulated_intercept + intercept_left
+
+            right_y_res = current_y_res[right_mask] - (intercept_right + coef_right * X_train[right_indices, pivot_idx])
+            right_coefficients = accumulated_coefficients.copy()
+            right_coefficients[pivot_idx] += coef_right
+            right_intercept = accumulated_intercept + intercept_right
+
+            # Recurse to both children
+            left_child_index = children_index[0]
+            right_child_index = children_index[1]
+            left_child = PilotAdapter._build_recursive(tree, left_child_index, X_train, left_indices,
+                                                              left_y_res, left_coefficients, left_intercept)
+            right_child = PilotAdapter._build_recursive(tree, right_child_index, X_train, right_indices,
+                                                               right_y_res, right_coefficients, right_intercept)
+
+            if node_type == 'pcon':
+                return PconNode(
+                    indices=current_indices,
+                    y_res=current_y_res,
+                    rss=float(np.sum(current_y_res ** 2)),
+                    pivot_idx=pivot_idx,
+                    pivot_value=pivot_value,
+                    left_child=left_child,
+                    right_child=right_child,
+                    left_model=ConstantNodeModel(intercept_left),
+                    right_model=ConstantNodeModel(intercept_right),
+                )
+            elif node_type == 'pconc':
+                return PconcNode(
+                    indices=current_indices,
+                    y_res=current_y_res,
+                    rss=float(np.sum(current_y_res ** 2)),
+                    pivot_idx=pivot_idx,
+                    pivot_value=pivot_value,
+                    left_child=left_child,
+                    right_child=right_child,
+                    left_model=ConstantNodeModel(intercept_left),
+                    right_model=ConstantNodeModel(intercept_right),
+                )
+            elif node_type == 'blin':
+                return BlinNode(
+                    indices=current_indices,
+                    y_res=current_y_res,
+                    rss=float(np.sum(current_y_res ** 2)),
+                    pivot_idx=pivot_idx,
+                    pivot_value=pivot_value,
+                    left_child=left_child,
+                    right_child=right_child,
+                    left_model=SimpleLinearNodeModel(pivot_idx, coef_left, intercept_left),
+                    right_model=SimpleLinearNodeModel(pivot_idx, coef_right, intercept_right),
+                )
+            else:  # node_type == 'plin'
+                return PlinNode(
+                    indices=current_indices,
+                    y_res=current_y_res,
+                    rss=float(np.sum(current_y_res ** 2)),
+                    pivot_idx=pivot_idx,
+                    pivot_value=pivot_value,
+                    left_child=left_child,
+                    right_child=right_child,
+                    left_model=SimpleLinearNodeModel(pivot_idx, coef_left, intercept_left),
+                    right_model=SimpleLinearNodeModel(pivot_idx, coef_right, intercept_right),
+                )
+        else:
+            raise ValueError(f"Unknown node type: {node_type}")
+
+    @staticmethod
+    def load_model(model_path):
+        raise NotImplementedError()
+
+    @staticmethod
+    def predict(X, model) -> np.ndarray:
+        return model.predict(X)

imote/app.py

@@ -0,0 +1,80 @@
+import logging
+
+import matplotlib
+matplotlib.use('agg')
+
+import dash
+import dash_bootstrap_components as dbc
+import dash_cytoscape as cyto
+from dash import Dash, html
+from flask import send_from_directory
+
+from imote.callbacks import register_all_callbacks
+from imote.components.stores import make_global_stores
+from imote.config import DIR_LIVE_OUTPUT, DIR_SAVED_VIZ_TREES
+
+cyto.load_extra_layouts()
+
+for plot_dir in (DIR_LIVE_OUTPUT / "regplots", DIR_LIVE_OUTPUT / "predsplots"):
+    plot_dir.mkdir(parents=True, exist_ok=True)
+    for old_plot in plot_dir.glob("*.svg"):
+        old_plot.unlink(missing_ok=True)
+DIR_SAVED_VIZ_TREES.mkdir(parents=True, exist_ok=True)
+
+app: Dash = dash.Dash(
+    __name__,
+    use_pages=True,
+    external_stylesheets=[dbc.themes.FLATLY, dbc.icons.BOOTSTRAP],
+    suppress_callback_exceptions=True,
+)
+app.title = "IMoTE: Interactive MOdel Tree Explorer"
+
+@app.server.route("/internal_regplots/<path:filename>")
+def serve_regplots(filename):
+    return send_from_directory(str(DIR_LIVE_OUTPUT / "regplots"), filename)
+
+
+@app.server.route("/internal_predsplots/<path:filename>")
+def serve_predsplots(filename):
+    return send_from_directory(str(DIR_LIVE_OUTPUT / "predsplots"), filename)
+
+
+navbar = dbc.NavbarSimple(
+    children=[
+        dbc.NavLink(page["name"], href=page["path"], active="exact")
+        for page in dash.page_registry.values()
+    ],
+    brand="IMoTE: Interactive MOdel Tree Explorer",
+    color="dark",
+    dark=True,
+)
+
+# Stores live OUTSIDE dash.page_container so their data survives navigating
+# between the Tree View and Explain pages.
+app.layout = html.Div(
+    [
+        navbar,
+        make_global_stores(),
+        dbc.Container(dash.page_container, fluid=True, class_name="pt-3"),
+    ]
+)
+
+register_all_callbacks(app)
+
+
+def _setup_logging(level: int):
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(levelname)s %(name)s: %(message)s"))
+    logger = logging.getLogger("imote")
+    logger.addHandler(handler)
+    logger.setLevel(level)
+
+
+def main():
+    _setup_logging(logging.INFO)
+    app.run()
+
+
+if __name__ == "__main__":
+    _setup_logging(logging.DEBUG)
+    app.run(debug=True)

imote/benchmark_info.py

@@ -0,0 +1,29 @@
+import numpy as np
+
+PMLB_DATASETS_CAT_IDS = {
+    '556_analcatdata_apnea2': np.array([0,1]),
+    '557_analcatdata_apnea1': np.array([0,1]),
+    '522_pm10': np.array([-1]),
+    '1028_SWD': np.array([0,1,2,3,4,5,6,7,8,9]),
+    '485_analcatdata_vehicle': np.array([0,1,2,3]),
+    '547_no2': np.array([-1]),
+    '665_sleuth_case2002': np.array([0,1,2,3]),
+    '210_cloud': np.array([0,1]),
+    '229_pwLinear': np.array([0,1,2,3,4,5,6,7,8,9]),
+    '230_machine_cpu': np.array([-1]),
+    '656_fri_c1_100_5': np.array([-1]),
+    '192_vineyard': np.array([-1]),
+    '653_fri_c0_250_25': np.array([-1]),
+    '687_sleuth_ex1605': np.array([-1]),
+    '651_fri_c0_100_25': np.array([-1]),
+    '658_fri_c3_250_25': np.array([-1]),
+    '294_satellite_image': np.array([-1]),
+    '1199_BNG_echoMonths': np.array([0,2,8]),
+    '505_tecator': np.array([-1]),
+    '560_bodyfat': np.array([-1]),
+    '197_cpu_act': np.array([-1]),
+    '225_puma8NH': np.array([-1]),
+    '503_wind': np.array([-1]),
+    '4544_GeographicalOriginalofMusic': np.array([-1]),
+    '537_houses': np.array([-1]),
+}

imote/callbacks/__init__.py

@@ -0,0 +1,16 @@
+from imote.callbacks.a_tree_info_callbacks import register_callbacks as register_tree_info_callbacks
+from imote.callbacks.b_node_callbacks import register_callbacks as register_node_callbacks
+from imote.callbacks.c_new_tree_callbacks import register_callbacks as register_new_tree_callbacks
+from imote.callbacks.d_edit_tree_callbacks import register_callbacks as register_edit_tree_callbacks
+from imote.callbacks.e_layout_callbacks import register_callbacks as register_layout_callbacks
+from imote.callbacks.f_highlight_callbacks import register_callbacks as register_highlight_callbacks
+from imote.callbacks.g_elements_callbacks import register_callbacks as register_elements_callbacks
+
+def register_all_callbacks(app):
+    register_tree_info_callbacks(app)
+    register_node_callbacks(app)
+    register_new_tree_callbacks(app)
+    register_edit_tree_callbacks(app)
+    register_layout_callbacks(app)
+    register_highlight_callbacks(app)
+    register_elements_callbacks(app)