ezmsg-tools 0.1.0__py3-none-any.whl

ezmsg/tools/__init__.py

@@ -0,0 +1 @@
+from .__version__ import __version__ as __version__

ezmsg/tools/__version__.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

ezmsg/tools/dag.py

@@ -0,0 +1,146 @@
+import asyncio
+import typing
+from collections import defaultdict
+from typing import TYPE_CHECKING
+from uuid import uuid4
+
+import ezmsg.core as ez
+import pandas as pd
+
+if TYPE_CHECKING:
+    import pygraphviz
+
+
+def get_graph(graph_address: typing.Tuple[str, int]) -> "pygraphviz.AGraph":
+    import pygraphviz as pgv
+
+    # Create a graphviz object with our graph components as nodes and our connections as edges.
+    G = pgv.AGraph(name="ezmsg-graphviz", strict=False, directed=True)
+    G.graph_attr["label"] = "ezmsg-graphviz"
+    G.graph_attr["rankdir"] = "TB"
+    # G.graph_attr["outputorder"] = "edgesfirst"
+    # G.graph_attr["ratio"] = "1.0"
+    # G.node_attr["shape"] = "circle"
+    # G.node_attr["fixedsize"] = "true"
+    G.node_attr["fontsize"] = "8"
+    G.node_attr["fontcolor"] = "#000000"
+    G.node_attr["style"] = "filled"
+    G.edge_attr["color"] = "#0000FF"
+    G.edge_attr["style"] = "setlinewidth(2)"
+
+    # Get the dag from the GraphService
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    dag = loop.run_until_complete(ez.graphserver.GraphService(address=graph_address).dag())
+
+    # Retrieve a description of the graph
+    graph_connections = dag.graph.copy()
+    # graph_connections is a dict with format
+    # {
+    #   'apath/unit/port': {'some/other_unit/port', 'yet/another/unit/port'},
+    # }
+    # where 'port' might be a pub (out) stream or a sub (input) stream.
+
+    b_refresh_dag = False
+    for k, v in graph_connections.items():
+        if "VISBUFF/INPUT_SIGNAL" in v:
+            b_refresh_dag = True
+            loop.run_until_complete(
+                ez.graphserver.GraphService(address=graph_address).disconnect(k, "VISBUFF/INPUT_SIGNAL")
+            )
+    if b_refresh_dag:
+        dag = loop.run_until_complete(ez.graphserver.GraphService(address=graph_address).dag())
+        graph_connections = dag.graph.copy()
+
+    # Generate UUID node names
+    node_map = {name: f'"{str(uuid4())}"' for name in set(graph_connections.keys())}
+
+    for node, conns in graph_connections.items():
+        for sub in conns:
+            G.add_edge(node_map[node], node_map[sub])
+
+    # Make a new dict `graph` with format {component_name: {sub_component: {stream: stream_full_path}}, ...}
+    def tree():
+        return defaultdict(tree)
+
+    graph: defaultdict = tree()
+    for node, conns in graph_connections.items():
+        subgraph = graph
+        path = node.split("/")
+        route = path[:-1]
+        stream = path[-1]
+        for seg in route:
+            subgraph = subgraph[seg]
+        subgraph[stream] = node
+
+    # Build out the AGraph recursively
+    def build_graph(g: defaultdict, agraph: pgv.AGraph):
+        for k, v in g.items():
+            if type(v) is defaultdict:
+                clust = agraph.add_subgraph(name=f"cluster_{k.lower()}", label=k, cluster=True)
+                build_graph(v, clust)
+            else:
+                agraph.add_node(node_map[v], name=v, label=k)
+
+    build_graph(graph, G)
+
+    return G
+
+
+def pgv2pd(g: "pygraphviz.AGraph") -> pd.DataFrame:
+    df_ps = pd.DataFrame(g.edges(), columns=["pub", "sub"])
+
+    def recurse_upstream(sub):
+        pubs = df_ps[df_ps["sub"] == sub]["pub"]
+        if len(pubs):
+            return recurse_upstream(pubs.iloc[0])
+        else:
+            return sub
+
+    nodes = []
+    for n in g.nodes():
+        coords = n.attr["pos"].split(",")
+        nodes.append(
+            {
+                # "id": n.name,
+                "name": n.attr["name"],
+                "x": float(coords[0]),
+                "y": float(coords[1]),
+                "upstream": g.get_node(recurse_upstream(n.name)).attr["name"],
+            }
+        )
+    return pd.DataFrame(nodes)
+
+
+async def crawl_coro(graph_address: tuple):
+    graph_service = ez.graphserver.GraphService(address=graph_address)
+    dag: ez.dag.DAG = await graph_service.dag()
+    graph_connections = dag.graph.copy()
+
+    # Construct the graph
+    def tree():
+        return defaultdict(tree)
+
+    graph: defaultdict = tree()
+
+    for node, conns in graph_connections.items():
+        subgraph = graph
+        path = node.split("/")
+        route = path[:-1]
+        stream = path[-1]
+        for seg in route:
+            subgraph = subgraph[seg]
+        subgraph[stream] = node
+
+    def recurse_get_unit_topics(g: defaultdict) -> list:
+        out = []
+        sub_graphs = [v for k, v in g.items() if isinstance(v, defaultdict)]
+        if len(sub_graphs):
+            for sub_graph in sub_graphs:
+                out += recurse_get_unit_topics(sub_graph)
+        else:
+            out.extend(list(g.values()))
+        return out
+
+    unit_topics = recurse_get_unit_topics(graph)
+    return unit_topics

ezmsg/tools/perfmon/main.py

@@ -0,0 +1,283 @@
+"""
+This is a plotly.dash application that monitors and visualizes the performance of an ezmsg system.
+
+Upon page load or changing the logger path, the application reads the CSV file at the given path
+and displays the data in a table.
+Additionally, every second, the application updates the table with the latest data from the CSV file.
+
+Whenever the table is updated, the application also updates a histogram graph that shows the average
+elapsed time for each topic.
+
+Only the last 1 minute of data is used in the table and graphs.
+"""
+
+import asyncio
+import datetime
+import io
+import typing
+from pathlib import Path
+
+import dash
+import dash_bootstrap_components as dbc
+import pandas as pd
+import plotly.express as px
+import pygtail
+from dash_extensions import Mermaid, enrich
+from ezmsg.baseproc.util.profile import get_logger_path
+from ezmsg.core.graphserver import GraphService
+
+PAGE_SIZE = 20
+
+app = dash.Dash("ezmsg Performance Monitor", external_stylesheets=[dbc.themes.CYBORG])
+
+state = dbc.Col(
+    [
+        dash.dcc.Interval(id="interval", interval=10_000, n_intervals=0),
+        dash.dcc.Store(id="df-store"),
+        dash.dcc.Store(id="last-dt-store"),
+        dash.html.Div(id="onload"),  # this div is used to trigger any functions that need to run on page load
+    ]
+)
+
+header_ui = dbc.Col(
+    [
+        dbc.Row(
+            [
+                dbc.Col(
+                    dbc.Input(
+                        id="logger-path",
+                        type="text",
+                        placeholder="logpath",
+                        debounce=True,
+                        valid=False,
+                    )
+                ),
+                dbc.Col(dbc.Switch(id="live-toggle", label="Live", value=False)),
+                # dbc.Col("History (s):", width=1),
+                # dbc.Col(dbc.Input(id="history-input", type="number", debounce=True, min=1, value=10)),
+            ]
+        ),
+    ]
+)
+
+dag = dbc.Col(
+    [
+        Mermaid(id="dag", config={"theme": "neutral"}),
+    ],
+    style={"width": "100%", "backgroundColor": "rgb(200, 200, 200)"},
+)
+
+table_summary = dbc.Col(
+    [
+        dbc.Row(dash.dcc.Graph(id="hist-graph", style={"width": "100%"})),
+        dbc.Row(dash.html.Div("Sum:", id="proc-sum", style={"width": "100%"})),
+        dbc.Row(
+            dash.dash_table.DataTable(
+                id="table",
+                data=[],
+                page_current=-1,
+                page_size=PAGE_SIZE,
+                page_action="custom",
+                style_header={"backgroundColor": "rgb(30, 30, 30)", "color": "white"},
+                style_data={"backgroundColor": "rgb(50, 50, 50)", "color": "white"},
+            )
+        ),
+    ]
+)
+
+app.layout = dash.html.Div(
+    children=[state, header_ui, dag, table_summary],
+    id="container",
+    className="dash-bootstrap",
+)
+
+
+@dash.callback(
+    dash.Output("logger-path", "value"),
+    enrich.Trigger("onload", "children"),
+    prevent_initial_call=False,
+)
+def on_load(_):
+    return str(get_logger_path())
+
+
+@dash.callback(
+    dash.Output("logger-path", "valid"),
+    dash.Input("logger-path", "value"),
+    prevent_initial_call=True,
+)
+def on_logger_path(logger_path: str) -> bool:
+    valid = False
+    logger_path = Path(logger_path)
+    if logger_path.exists():
+        offset_path = logger_path.parent / (logger_path.name + ".offset")
+        offset_path.unlink(missing_ok=True)
+        valid = logger_path.stat().st_size > 0
+    return valid
+
+
+def _trim_df(df: pd.DataFrame, history_sec: float = 10.0) -> pd.DataFrame:
+    last_dt = df["Time"].iloc[-1]
+    hist_lim = last_dt - datetime.timedelta(seconds=history_sec)
+    return df[df["Time"] >= hist_lim]
+
+
+@dash.callback(
+    dash.Output("df-store", "data"),
+    dash.Output("last-dt-store", "data"),
+    dash.Input("logger-path", "value"),
+    # dash.Input("history-input", "value"),
+    prevent_initial_call=True,
+)
+def load_once(
+    logger_path: str,
+    # history_sec
+) -> tuple[list[dict[str, typing.Any]], datetime.datetime]:
+    if logger_path is None or not Path(logger_path).exists():
+        raise dash.exceptions.PreventUpdate
+    try:
+        df = pd.read_csv(logger_path, header=0, parse_dates=["Time"])
+    except pd.errors.EmptyDataError:
+        raise dash.exceptions.PreventUpdate
+    # Rewrite logger-path.offset with the current offset.
+    tail = pygtail.Pygtail(logger_path)
+    tail.read_from_end = True
+    tail.update_offset_file()
+    # Trim any rows with headers
+    b_bad = df["Time"].astype(str) == "Time"
+    if b_bad.any():
+        df = df[~b_bad]
+        # Reinterpret the columns:
+        # Time (datetime64), Source (obj), Topic (obj), SampleTime (float64), PerfCounter (float64), Elapsed (float64)
+        df["Time"] = pd.to_datetime(df["Time"])
+        for col in ["SampleTime", "PerfCounter", "Elapsed"]:
+            df[col] = pd.to_numeric(df[col])
+    # Trim dataframe to only include the last history_sec of data.
+    df = _trim_df(df, history_sec=10.0)  # TODO: Get history_sec from widget
+    last_dt = df["Time"].iloc[-1]
+    data = df.to_dict("records")
+    return data, last_dt
+
+
+@dash.callback(
+    dash.Output("df-store", "data", allow_duplicate=True),
+    dash.Output("last-dt-store", "data", allow_duplicate=True),
+    [
+        dash.Input("interval", "n_intervals"),
+        dash.Input("live-toggle", "value"),
+        dash.State("logger-path", "value"),
+        dash.State("df-store", "data"),
+        dash.State("last-dt-store", "data"),
+    ],
+    prevent_initial_call=True,
+)
+def interval_callback(_, toggle_state, logger_path, data, last_dt):
+    if not toggle_state:
+        raise dash.exceptions.PreventUpdate
+
+    tail = pygtail.Pygtail(logger_path)
+    new_lines = tail.read()
+
+    if not new_lines:
+        raise dash.exceptions.PreventUpdate
+
+    if data is not None:
+        df = pd.DataFrame.from_dict(data)
+        df["Time"] = pd.to_datetime(df["Time"])
+        new_df = pd.read_csv(io.StringIO(new_lines), names=df.columns, parse_dates=["Time"])
+        df = pd.concat([df, new_df], ignore_index=True)
+    else:
+        df = pd.read_csv(io.StringIO(new_lines), header=0, parse_dates=["Time"])
+    df = _trim_df(df, history_sec=10.0)  # TODO: Get history_sec from widget
+    last_dt = df["Time"].iloc[-1]
+    return df.to_dict("records"), last_dt
+
+
+@dash.callback(
+    dash.Output("dag", "chart"),
+    [
+        dash.Input("df-store", "data"),
+        dash.State("logger-path", "value"),
+    ],
+    prevent_initial_call=True,
+    memoize=True,
+)
+def update_dag(data, logger_path):
+    async def _get_formatted_graph():
+        graph_service = GraphService(("127.0.0.1", 25978))
+        graph_out = await graph_service.get_formatted_graph(fmt="mermaid", direction="LR")
+        return graph_out
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    graph_str = loop.run_until_complete(_get_formatted_graph())
+    if not graph_str:
+        logger_path = Path(logger_path)
+        graph_path = logger_path.parent / (logger_path.stem + ".mermaid")
+        if not graph_path.exists():
+            return ""
+        with graph_path.open() as f:
+            graph_str = f.read()
+
+    df = pd.DataFrame.from_dict(data)
+    df["Time"] = pd.to_datetime(df["Time"])
+
+    topic_means = df.groupby("Topic")["Elapsed"].mean()
+    max_elapsed = topic_means.max()
+    for topic, mean in topic_means.items():
+        topic_str = topic.split("/")[-1].lower()
+        # https://mermaid.js.org/syntax/flowchart.html#styling-a-node
+        color = px.colors.find_intermediate_color((0, 0.0, 1.0), (1.0, 0.0, 0.0), mean / max_elapsed)
+        fill_str = "".join([f"{int(c * 255):02x}" for c in color])
+        # style id2 fill:#bbf,stroke:#f66,stroke-width:2px,color:#fff,stroke-dasharray: 5 5
+        graph_str += f"  style {topic_str} fill:#{fill_str}80\n"
+    return graph_str
+
+
+@dash.callback(
+    dash.Output("table", "data"),
+    dash.Output("table", "page_current"),
+    dash.Input("df-store", "data"),
+    dash.Input("table", "page_current"),
+    dash.Input("table", "page_size"),
+    prevent_initial_call=True,
+    memoize=True,
+)
+def update_table(data, page_current, page_size):
+    df = pd.DataFrame.from_dict(data)
+    df["Time"] = pd.to_datetime(df["Time"])
+    if page_current < 0:
+        page_current = int(len(df) // PAGE_SIZE) - 1
+    out_data = df.iloc[page_current * page_size : (page_current + 1) * page_size].to_dict("records")
+    return out_data, page_current
+
+
+@dash.callback(
+    dash.Output("hist-graph", "figure"),
+    dash.Output("proc-sum", "children"),
+    dash.Input("df-store", "data"),
+    prevent_initial_call=True,
+    memoize=True,
+)
+def update_hist(data):
+    df = pd.DataFrame.from_dict(data)
+    df["Time"] = pd.to_datetime(df["Time"])
+    topic_means = df.groupby("Topic")[["PerfCounter", "Elapsed"]].mean()
+    fig = px.bar(
+        topic_means,
+        y="Elapsed",
+        hover_data=["Elapsed"],
+        color="Elapsed",
+        labels={"Elapsed": "Processing time per chunk (ms)"},
+        height=400,
+        color_continuous_scale="Bluered",
+    )
+    # px.histogram(df, x="Topic", y="Elapsed", histfunc="avg")
+    fig.update_layout(height=400, showlegend=False, template="plotly_dark")
+    fig.layout.coloraxis.colorbar.title = None
+    proc_sum = topic_means["Elapsed"].sum()
+    return fig, f"Sum: {proc_sum:.2f} ms"
+
+
+if __name__ == "__main__":
+    app.run(debug=True)

ezmsg/tools/proc.py

@@ -0,0 +1,87 @@
+import asyncio
+import multiprocessing
+import multiprocessing.connection
+import typing
+
+import ezmsg.core as ez
+
+from .shmem.shmem import ShMemCircBuff, ShMemCircBuffSettings
+
+BUF_DUR = 3.0
+
+
+class EzMonitorProcess(multiprocessing.Process):
+    def __init__(
+        self,
+        settings: ShMemCircBuffSettings,
+        topic: str,
+        address: typing.Optional[typing.Tuple[str, int]] = None,
+    ) -> None:
+        super().__init__()
+        self._settings = settings
+        self._topic = topic
+        self._graph_address = address
+
+    def run(self) -> None:
+        comps = {"SHMEM": ShMemCircBuff(self._settings)}
+        conns = ((self._topic, comps["SHMEM"].INPUT_SIGNAL),)
+        ez.run(components=comps, connections=conns, graph_address=self._graph_address)
+
+
+class EZProcManager:
+    """
+    Manages the subprocess that runs an ezmsg pipeline comprising a single ShMemCircBuff unit connected to a pipeline.
+    The unit must be parameterized with the correct shared memory name.
+    We do not actually interact with the shared memory in this class. See .mirror.EzmsgShmMirror.
+    """
+
+    def __init__(self, graph_ip: str, graph_port: int, buf_dur: float = BUF_DUR) -> None:
+        self._graph_addr: typing.Tuple[str, int] = (graph_ip, graph_port)
+        self._buf_dur = buf_dur
+        self._proc = None
+        self._node_path: typing.Optional[str] = None
+        self._remote_conn, self._conn = multiprocessing.Pipe()
+
+    @property
+    def node_path(self) -> str:
+        return self._node_path
+
+    @property
+    def conn(self) -> typing.Optional[multiprocessing.connection.Connection]:
+        return self._conn
+
+    def reset(self, node_path: typing.Optional[str]) -> None:
+        self._cleanup_subprocess()
+        self._node_path = node_path
+        self._init_subprocess()
+
+    def cleanup(self):
+        self._cleanup_subprocess()
+
+    def _cleanup_subprocess(self) -> None:
+        if self._proc is not None:
+            self._conn.send("quit")
+            # Close process
+            self._proc.join()
+            self._proc = None
+
+            # TODO: Somehow closing the proc doesn't always clear the VISBUFF connections.
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(
+                ez.graphserver.GraphService(address=self._graph_addr).disconnect(
+                    self._node_path, "VISBUFF/INPUT_SIGNAL"
+                )
+            )
+
+    def _init_subprocess(self, axis: str = "time"):
+        unit_settings = ShMemCircBuffSettings(
+            shmem_name="buff_" + self._node_path,
+            buf_dur=self._buf_dur,
+            conn=self._remote_conn,
+            axis=axis,
+        )
+        self._proc = EzMonitorProcess(unit_settings, self._node_path, address=self._graph_addr)
+        self._proc.start()
+
+    # if self._rend_conn.poll(): msg = self._rend_conn.recv()