ezmsg 3.3.3__tar.gz → 3.4.0__tar.gz

ezmsg-3.4.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.1
+Name: ezmsg
+Version: 3.4.0
+Summary: A simple DAG-based computation model
+License: MIT
+Author: Milsap, Griffin
+Author-email: griffin.milsap@gmail.com
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: all-ext
+Provides-Extra: sigproc
+Provides-Extra: vispy
+Provides-Extra: websocket
+Provides-Extra: zmq
+Requires-Dist: ezmsg-sigproc ; extra == "sigproc" or extra == "all-ext"
+Requires-Dist: ezmsg-vispy ; extra == "vispy" or extra == "all-ext"
+Requires-Dist: ezmsg-websocket ; extra == "websocket" or extra == "all-ext"
+Requires-Dist: ezmsg-zmq ; extra == "zmq" or extra == "all-ext"
+Requires-Dist: typing-extensions (>=4.9.0,<5.0.0)
+Description-Content-Type: text/markdown
+
+# <img src="https://raw.githubusercontent.com/iscoe/ezmsg/main/docs/source/logo.png" width="50"/> ezmsg
+
+Messaging and Multiprocessing.
+
+`ezmsg` is a pure-Python implementation of a directed acyclic graph (DAG) pub/sub messaging pattern based on [`labgraph`](https://github.com/facebookresearch/labgraph) which is optimized and intended for use in constructing real-time software. `ezmsg` implements much of the `labgraph` API (with a few notable differences), and owes a lot of its design to the `labgraph` developers/project.
+
+`ezmsg` is very fast and uses Python's `multiprocessing.shared_memory` module to facilitate efficient message passing without C++ or any compilation/build tooling.
+
+## Installation
+
+`pip install ezmsg`
+
+## Dependencies
+
+- Due to reliance on `multiprocessing.shared_memory`, `ezmsg` requires **minimum Python 3.8**.
+- `typing_extensions`
+
+Testing `ezmsg` requires:
+
+- `pytest`
+- `pytest-cov`
+- `pytest-asyncio`
+- `numpy`
+
+## Setup (Development)
+
+```bash
+$ python3 -m venv env
+$ source env/bin/activate
+(env) $ pip install --upgrade pip poetry
+(env) $ poetry install --with test
+
+(env) $ python -m pytest tests # Optionally, Perform tests
+```
+
+Note that it is generally recommended to install poetry into its own standalone venv via the `pipx` cli tool.
+
+## Documentation
+
+https://ezmsg.readthedocs.io/en/latest/
+
+`ezmsg` is very similar to [`labgraph`](https://www.github.com/facebookresearch/labgraph), so you might get a primer with their documentation and examples. Additionally, there are many examples provided in the examples/tests directories strewn throughout this repository.
+
+## Extensions
+
+`ezmsg` extensions can be installed individually or all at once. To install all the extension packages in one go, you can use the following command:
+
+```bash
+pip install "ezmsg[all_ext]"
+```
+
+This will install all the available public extension packages for `ezmsg` that are listed in `pyproject.toml`.
+If you prefer to install a subset of extension packages, you can use the following command:
+
+```bash
+pip install "ezmsg[zmq,sigproc,...]"
+```
+
+Please note that the `ezmsg` package itself can still be installed without any additional extensions using `pip install ezmsg`.
+
+Extensions can be managed manually as well. Here are some of the extensions we manage or are aware of:
+
+- [ezmsg-sigproc](https://github.com/ezmsg-org/ezmsg-sigproc) -- Timeseries signal processing modules
+- [ezmsg-websocket](https://github.com/ezmsg-org/ezmsg-websocket) -- Websocket server and client nodes for `ezmsg` graphs
+- [ezmsg-zmq](https://github.com/ezmsg-org/ezmsg-zmq) -- ZeroMQ pub and sub nodes for `ezmsg` graphs
+- [ezmsg-panel](https://github.com/griffinmilsap/ezmsg-panel) -- Plotting tools for `ezmsg` that use [panel](https://github.com/holoviz/panel)
+- [ezmsg-blackrock](https://github.com/griffinmilsap/ezmsg-blackrock) -- Interface for Blackrock Cerebus ecosystem (incl. Neuroport) using `pycbsdk`
+- [ezmsg-lsl](https://github.com/ezmsg-org/ezmsg-lsl) -- Source unit for LSL Inlet and sink unit for LSL Outlet
+- [ezmsg-unicorn](https://github.com/griffinmilsap/ezmsg-unicorn) -- g.tec Unicorn Hybrid Black integration for `ezmsg`
+- [ezmsg-gadget](https://github.com/griffinmilsap/ezmsg-gadget) -- USB-gadget with HID control integration for Raspberry Pi (Zero/W/2W, 4, CM4)
+- [ezmsg-openbci](https://github.com/griffinmilsap/ezmsg-openbci) -- OpenBCI Cyton serial interface for `ezmsg`
+- [ezmsg-ssvep](https://github.com/griffinmilsap/ezmsg-ssvep) -- Tools for running SSVEP experiments with `ezmsg`
+- [ezmsg-vispy](https://github.com/pperanich/ezmsg-vispy) -- `ezmsg` visualization toolkit using PyQt6 and vispy.
+
+## Publications
+
+A collection of academic papers, journals, and other publications that have cited or utilized `ezmsg` in research and development.
+These publications provide insights into the practical applications and impact of `ezmsg` in various fields.
+
+- [A click-based electrocorticographic brain-computer interface enables long-term high-performance switch-scan spelling](https://doi.org/10.21203/rs.3.rs-3158792/v1)
+- [Stable Decoding from a Speech BCI Enables Control for an Individual with ALS without Recalibration for 3 Months](https://doi.org/10.1002/advs.202304853)
+ 
+## Financial Support
+
+`ezmsg` is supported by Johns Hopkins University (JHU), the JHU Applied Physics Laboratory (APL), and by the Wyss Center for Bio and Neuro Engineering.
+

ezmsg-3.4.0/README.md

@@ -0,0 +1,85 @@
+# <img src="https://raw.githubusercontent.com/iscoe/ezmsg/main/docs/source/logo.png" width="50"/> ezmsg
+
+Messaging and Multiprocessing.
+
+`ezmsg` is a pure-Python implementation of a directed acyclic graph (DAG) pub/sub messaging pattern based on [`labgraph`](https://github.com/facebookresearch/labgraph) which is optimized and intended for use in constructing real-time software. `ezmsg` implements much of the `labgraph` API (with a few notable differences), and owes a lot of its design to the `labgraph` developers/project.
+
+`ezmsg` is very fast and uses Python's `multiprocessing.shared_memory` module to facilitate efficient message passing without C++ or any compilation/build tooling.
+
+## Installation
+
+`pip install ezmsg`
+
+## Dependencies
+
+- Due to reliance on `multiprocessing.shared_memory`, `ezmsg` requires **minimum Python 3.8**.
+- `typing_extensions`
+
+Testing `ezmsg` requires:
+
+- `pytest`
+- `pytest-cov`
+- `pytest-asyncio`
+- `numpy`
+
+## Setup (Development)
+
+```bash
+$ python3 -m venv env
+$ source env/bin/activate
+(env) $ pip install --upgrade pip poetry
+(env) $ poetry install --with test
+
+(env) $ python -m pytest tests # Optionally, Perform tests
+```
+
+Note that it is generally recommended to install poetry into its own standalone venv via the `pipx` cli tool.
+
+## Documentation
+
+https://ezmsg.readthedocs.io/en/latest/
+
+`ezmsg` is very similar to [`labgraph`](https://www.github.com/facebookresearch/labgraph), so you might get a primer with their documentation and examples. Additionally, there are many examples provided in the examples/tests directories strewn throughout this repository.
+
+## Extensions
+
+`ezmsg` extensions can be installed individually or all at once. To install all the extension packages in one go, you can use the following command:
+
+```bash
+pip install "ezmsg[all_ext]"
+```
+
+This will install all the available public extension packages for `ezmsg` that are listed in `pyproject.toml`.
+If you prefer to install a subset of extension packages, you can use the following command:
+
+```bash
+pip install "ezmsg[zmq,sigproc,...]"
+```
+
+Please note that the `ezmsg` package itself can still be installed without any additional extensions using `pip install ezmsg`.
+
+Extensions can be managed manually as well. Here are some of the extensions we manage or are aware of:
+
+- [ezmsg-sigproc](https://github.com/ezmsg-org/ezmsg-sigproc) -- Timeseries signal processing modules
+- [ezmsg-websocket](https://github.com/ezmsg-org/ezmsg-websocket) -- Websocket server and client nodes for `ezmsg` graphs
+- [ezmsg-zmq](https://github.com/ezmsg-org/ezmsg-zmq) -- ZeroMQ pub and sub nodes for `ezmsg` graphs
+- [ezmsg-panel](https://github.com/griffinmilsap/ezmsg-panel) -- Plotting tools for `ezmsg` that use [panel](https://github.com/holoviz/panel)
+- [ezmsg-blackrock](https://github.com/griffinmilsap/ezmsg-blackrock) -- Interface for Blackrock Cerebus ecosystem (incl. Neuroport) using `pycbsdk`
+- [ezmsg-lsl](https://github.com/ezmsg-org/ezmsg-lsl) -- Source unit for LSL Inlet and sink unit for LSL Outlet
+- [ezmsg-unicorn](https://github.com/griffinmilsap/ezmsg-unicorn) -- g.tec Unicorn Hybrid Black integration for `ezmsg`
+- [ezmsg-gadget](https://github.com/griffinmilsap/ezmsg-gadget) -- USB-gadget with HID control integration for Raspberry Pi (Zero/W/2W, 4, CM4)
+- [ezmsg-openbci](https://github.com/griffinmilsap/ezmsg-openbci) -- OpenBCI Cyton serial interface for `ezmsg`
+- [ezmsg-ssvep](https://github.com/griffinmilsap/ezmsg-ssvep) -- Tools for running SSVEP experiments with `ezmsg`
+- [ezmsg-vispy](https://github.com/pperanich/ezmsg-vispy) -- `ezmsg` visualization toolkit using PyQt6 and vispy.
+
+## Publications
+
+A collection of academic papers, journals, and other publications that have cited or utilized `ezmsg` in research and development.
+These publications provide insights into the practical applications and impact of `ezmsg` in various fields.
+
+- [A click-based electrocorticographic brain-computer interface enables long-term high-performance switch-scan spelling](https://doi.org/10.21203/rs.3.rs-3158792/v1)
+- [Stable Decoding from a Speech BCI Enables Control for an Individual with ALS without Recalibration for 3 Months](https://doi.org/10.1002/advs.202304853)
+ 
+## Financial Support
+
+`ezmsg` is supported by Johns Hopkins University (JHU), the JHU Applied Physics Laboratory (APL), and by the Wyss Center for Bio and Neuro Engineering.

ezmsg-3.4.0/pyproject.toml

@@ -0,0 +1,79 @@
+[tool.poetry]
+name = "ezmsg"
+version = "3.4.0"
+description = "A simple DAG-based computation model"
+authors = [
+  "Milsap, Griffin <griffin.milsap@gmail.com>",
+  "Peranich, Preston <pperanich@gmail.com>",
+]
+license = "MIT"
+readme = "README.md"
+packages = [{ include = "ezmsg", from = "src" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]
+
+[tool.poetry.scripts]
+ezmsg = "ezmsg.core.command:cmdline"
+
+[tool.poetry.dependencies]
+python = "^3.8"
+typing-extensions = "^4.9.0"
+ezmsg-sigproc = { version = "*", source = "pypi", optional = true }
+ezmsg-websocket = { version = "*", source = "pypi", optional = true }
+ezmsg-zmq = { version = "*", source = "pypi", optional = true }
+ezmsg-vispy = { version = "*", source = "pypi", optional = true }
+# ezmsg-panel = { git = "https://github.com/griffinmilsap/ezmsg-panel.git", rev = "main", optional = true }
+# ezmsg-blackrock = { python = "^3.9", git = "https://github.com/CerebusOSS/ezmsg-blackrock.git", rev = "main", optional = true }
+# ezmsg-unicorn = { git = "https://github.com/griffinmilsap/ezmsg-unicorn.git", rev = "main", optional = true }
+# ezmsg-gadget = { git = "https://github.com/griffinmilsap/ezmsg-gadget.git", rev = "main", optional = true }
+# ezmsg-openbci = { git = "https://github.com/griffinmilsap/ezmsg-openbci.git", rev = "main", optional = true }
+# ezmsg-ssvep = { git = "https://github.com/griffinmilsap/ezmsg-ssvep.git", rev = "main", optional = true }
+
+
+[tool.poetry.group.test.dependencies]
+pytest = "^7.0.0"
+pytest-asyncio = "*"
+pytest-cov = "*"
+numpy = "^1.24.2"
+flake8 = "*"
+
+
+[tool.poetry.group.docs.dependencies]
+sphinx = "<7.2"
+sphinx-rtd-theme = "^2.0.0"
+ezmsg-sigproc = { version = "*", source = "pypi" }
+
+[tool.poetry.extras]
+sigproc = ["ezmsg-sigproc"]
+websocket = ["ezmsg-websocket"]
+zmq = ["ezmsg-zmq"]
+# panel = ["ezmsg-panel"]
+# blackrock = ["ezmsg-blackrock"]
+# unicorn = ["ezmsg-unicorn"]
+# gadget = ["ezmsg-gadget"]
+# openbci = ["ezmsg-openbci"]
+# ssvep = ["ezmsg-ssvep"]
+vispy = ["ezmsg-vispy"]
+all_ext = [
+  "ezmsg-sigproc",
+  "ezmsg-websocket",
+  "ezmsg-zmq",
+  # "ezmsg-panel",
+  # "ezmsg-blackrock",
+  # "ezmsg-unicorn",
+  # "ezmsg-gadget",
+  # "ezmsg-openbci",
+  # "ezmsg-ssvep",
+  "ezmsg-vispy",
+]
+
+[tool.pytest.ini_options]
+addopts = ["--import-mode=importlib"]
+pythonpath = ["src", "tests"]
+testpaths = "tests"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

{ezmsg-3.3.3 → ezmsg-3.4.0/src}/ezmsg/core/__init__.py

@@ -1,3 +1,8 @@
+import importlib.metadata
+
+
+__version__ = importlib.metadata.version("ezmsg")
+
 __all__ = [
     "task",
     "publisher",
@@ -60,3 +65,4 @@ logger.addHandler(handler)
 
 LOGLEVEL = os.environ.get("EZMSG_LOGLEVEL", "INFO").upper()
 logger.setLevel(LOGLEVEL)
+logger.debug(f'Log level set to {LOGLEVEL}')

{ezmsg-3.3.3 → ezmsg-3.4.0/src}/ezmsg/core/backend.py

@@ -167,6 +167,29 @@ def run(
     force_single_process: bool = False,
     **components_kwargs: Component,
 ) -> None:
+    """
+    Begin execution of a set of :obj:`Component` s.
+
+    `The old method` :obj:`run_system` `has been deprecated and uses` ``run()`` `instead.`
+
+    Args:
+        components: represents the nodes in the directed acyclic graph. It is a dictionary which contains the
+            ``Components`` to be run mapped to string names. On initialization, ``ezmsg`` will call ``initialize()``
+            for each :obj:`Unit` and ``configure()`` for each :obj:`Collection`, if defined.
+        root_name:
+        connections: represents the edges is a ``NetworkDefinition`` which connects
+            ``OutputStreams`` to ``InputStreams``. On initialization, ``ezmsg`` will create a directed acyclic graph
+            using the contents of this parameter.
+        process_components: a list of ``Components`` which should live in their own process.
+        backend_process: is currently under development.
+        graph_address: the hostname and port of the graph server which ``ezmsg`` should connect to.
+            If not defined, ``ezmsg`` will start a new graph server at 127.0.0.1:25978.
+        force_single_process: run all ``Components`` in one process.
+            This is necessary when running ``ezmsg`` in a notebook.
+        components_kwargs:
+    """
+    # FIXME: This function is the last major re-implementation needed to make this
+    # codebase more maintainable.
     graph_service = GraphService(graph_address)
     shm_service = SHMService()
 
@@ -195,16 +218,20 @@ def run(
         if execution_context is None:
             return
 
+        # FIXME: When done this way, we don't exit the graph_context on exception
         async def create_graph_context() -> GraphContext:
             return await GraphContext(graph_service, shm_service).__aenter__()
 
-        async def cleanup_graph(context: GraphContext) -> None:
-            await context.__aexit__(None, None, None)
-
+        # FIXME: This sort of stuff should all be done in a separate async function...
+        # Done this way, its ugly as hell and opens us up to a lot of issues with
+        # entering and exiting context properly on exceptions.
         graph_context = asyncio.run_coroutine_threadsafe(
             create_graph_context(), loop
         ).result()
 
+        async def cleanup_graph() -> None:
+            await graph_context.__aexit__(None, None, None)
+
         async def setup_graph() -> None:
             for edge in execution_context.connections:
                 await graph_context.connect(*edge)
@@ -252,9 +279,7 @@ def run(
 
         finally:
             join_all_other_processes()
-            asyncio.run_coroutine_threadsafe(
-                cleanup_graph(graph_context), loop
-            ).result()
+            asyncio.run_coroutine_threadsafe(cleanup_graph(), loop).result()
 
 
 def collect_processes(

{ezmsg-3.3.3 → ezmsg-3.4.0/src}/ezmsg/core/backendprocess.py

@@ -41,10 +41,17 @@ logger = logging.getLogger("ezmsg")
 
 
 class Complete(Exception):
+    """
+    A type of ``Exception`` which signals to ``ezmsg`` that the function can be shut down gracefully.
+    If all functions in all :obj:`Units` raise ``Complete``, the entire pipeline will terminate execution.
+    """
     pass
 
 
 class NormalTermination(Exception):
+    """
+    A type of ``Exception`` which signals to ``ezmsg`` that the pipeline can be shut down gracefully.
+    """
     pass
 
 
@@ -294,32 +301,28 @@ class DefaultBackendProcess(BackendProcess):
             )
 
         pub_fn = perf_publish if hasattr(task, TIMEIT_ATTR) else publish
+        
+        call_fn = lambda _: task(unit)
+        signature = inspect.signature(task)
+        if len(signature.parameters) == 1:
+            call_fn = lambda _: task(unit)
+        elif len(signature.parameters) == 2:
+            call_fn = lambda msg: task(unit, msg)
+        else:
+            logger.error(f'Incompatible call signature on task: {task.__name__}')
 
         @wraps(task)
         async def wrapped_task(msg: Any = None) -> None:
             try:
-                # If we don't sub or pub anything, we are a simple task
-                if not hasattr(task, SUBSCRIBES_ATTR) and not hasattr(
-                    task, PUBLISHES_ATTR
-                ):
-                    await task(unit)
-
-                # No subscriptions; only publications...
-                elif not hasattr(task, SUBSCRIBES_ATTR):
-                    async for stream, obj in task(unit):
+                result = call_fn(msg)
+                if inspect.isasyncgen(result):
+                    async for stream, obj in result:
+                        if obj and getattr(task, ZERO_COPY_ATTR, False) and obj is msg:
+                            obj = deepcopy(obj)
                         await pub_fn(stream, obj)
 
-                # Subscribers need to be called with a message
-                else:
-                    if not getattr(task, ZERO_COPY_ATTR):
-                        msg = deepcopy(msg)
-                    if hasattr(task, PUBLISHES_ATTR):
-                        async for stream, obj in task(unit, msg):
-                            if getattr(task, ZERO_COPY_ATTR) and obj is msg:
-                                obj = deepcopy(obj)
-                            await pub_fn(stream, obj)
-                    else:
-                        await task(unit, msg)
+                elif asyncio.iscoroutine(result):
+                    await result
 
             except Complete:
                 logger.info(f"{task_address} Complete")
@@ -386,3 +389,4 @@ def new_threaded_event_loop(
         loop.call_soon_threadsafe(loop.stop)
         thread.join()
         loop.close()
+        logger.debug("Task thread stopped and closed")

{ezmsg-3.3.3 → ezmsg-3.4.0/src}/ezmsg/core/collection.py

@@ -34,21 +34,36 @@ class CollectionMeta(ComponentMeta):
 
 
 class Collection(Component, metaclass=CollectionMeta):
-    """Collections can contain subunits and connect them together"""
+    """
+    Connects :obj:`Unit` s together by defining a graph which connects :obj:`OutputStream` s to :obj:`InputStream` s.
+    """
 
-    def __init__(self, settings: typing.Optional[Settings] = None):
-        super(Collection, self).__init__(settings)
+    def __init__(self, *args, settings: typing.Optional[Settings] = None, **kwargs):
+        super(Collection, self).__init__(*args, settings=settings, **kwargs)
 
         self._components = deepcopy(self.__class__.__components__)
         for comp_name, comp in self.components.items():
             setattr(self, comp_name, comp)
 
     def configure(self) -> None:
-        """This is where to percolate apply_settings to subnodes"""
+        """
+        A lifecycle hook that runs when the :obj:`Collection` is instantiated.
+        This is the best place to call ``Unit.apply_settings()`` on each member :obj:`Unit` of the :obj:`Collection`.
+        """
         ...
 
     def network(self) -> NetworkDefinition:
+        """
+        Override this method and have the definition return a :obj:`NetworkDefinition` which defines how
+        :obj:`InputStream` and :obj:`OutputStream` from member :obj:`Unit` s will be connected.
+        """
         return ()
 
     def process_components(self) -> typing.Collection[Component]:
+        """
+        Override this method and have the definition return a tuple which contains :obj:`Unit` and :obj:`Collection`
+        which should run in their own processes.
+
+        Return: the :obj:`Collection`.
+        """
         return (self,)

{ezmsg-3.3.3 → ezmsg-3.4.0/src}/ezmsg/core/command.py

@@ -1,9 +1,12 @@
 import os
+import sys
+import base64
 import asyncio
 import argparse
 import logging
 import subprocess
 import typing
+import webbrowser
 
 from collections import defaultdict
 from uuid import uuid4
@@ -43,7 +46,7 @@ def cmdline() -> None:
     parser.add_argument(
         "command",
         help="command for ezmsg",
-        choices=["serve", "start", "shutdown", "graphviz"],
+        choices=["serve", "start", "shutdown", "graphviz", "mermaid"],
     )
 
     parser.add_argument("--address", help="Address for GraphServer", default=None)
@@ -95,7 +98,7 @@ async def run_command(cmd: str, graph_address: Address, shm_address: Address) ->
 
     elif cmd == "start":
         popen = subprocess.Popen(
-            ["python", "-m", "ezmsg.core", "serve", f"--address={graph_address}"]
+            [sys.executable, "-m", "ezmsg.core", "serve", f"--address={graph_address}"]
         )
 
         while True:
@@ -113,10 +116,14 @@ async def run_command(cmd: str, graph_address: Address, shm_address: Address) ->
     elif cmd == "shutdown":
         try:
             await graph_service.shutdown()
-            logger.info(f"Issued shutdown command to GraphServer @ {graph_service.address}")
+            logger.info(
+                f"Issued shutdown command to GraphServer @ {graph_service.address}"
+            )
 
         except ConnectionRefusedError:
-            logger.warning(f"Could not issue shutdown command to GraphServer @ {graph_service.address}; server not running?")
+            logger.warning(
+                f"Could not issue shutdown command to GraphServer @ {graph_service.address}; server not running?"
+            )
 
     elif cmd == "graphviz":
         try:
@@ -148,7 +155,9 @@ async def run_command(cmd: str, graph_address: Address, shm_address: Address) ->
                         new_conns = conns.copy()
                         new_conns.remove(proxy_topic)
                         new_conns.union(downstreams)
-                        logger.info(f"Updating connections for {node} from {conns} to {new_conns}")
+                        logger.info(
+                            f"Updating connections for {node} from {conns} to {new_conns}"
+                        )
                         graph_connections[node] = new_conns
 
         graph_connections = dag.graph.copy()
@@ -192,7 +201,7 @@ async def run_command(cmd: str, graph_address: Address, shm_address: Address) ->
                         ),
                         IND,
                     )
-                elif type(g[leaf]) == str:
+                elif isinstance(g[leaf], str):
                     out += indent(f"{node_map[g[leaf]]} [label={leaf}];" + "\n", IND)
             return out
 
@@ -209,3 +218,102 @@ async def run_command(cmd: str, graph_address: Address, shm_address: Address) ->
         )
 
         print(graphviz_out)
+    elif cmd == "mermaid":
+        try:
+            dag: DAG = await graph_service.dag()
+        except (ConnectionRefusedError, ConnectionResetError):
+            logger.info(
+                f"GraphServer not running @{graph_address}, or host is refusing connections"
+            )
+            return
+
+        graph_connections = dag.graph.copy()
+        # Let's eliminate proxy topics, i.e. connections with inputs and outputs.
+        source_nodes = []
+        for node, conns in graph_connections.items():
+            if len(conns) > 0:
+                source_nodes += [node]
+        proxy_topics = []
+        for conns in graph_connections.values():
+            for conn in conns:
+                if conn in source_nodes and conn not in proxy_topics:
+                    proxy_topics += [conn]
+        # Replace Proxy Topics with actual source and downstream
+        for proxy_topic in proxy_topics:
+            downstreams = graph_connections.pop(proxy_topic)
+            logger.info(f"{proxy_topic} downstream connetions: {downstreams}")
+            for node, conns in graph_connections.items():
+                for conn in conns:
+                    if conn == proxy_topic:
+                        new_conns = conns.copy()
+                        new_conns.remove(proxy_topic)
+                        new_conns.union(downstreams)
+                        logger.info(
+                            f"Updating connections for {node} from {conns} to {new_conns}"
+                        )
+                        graph_connections[node] = new_conns
+
+        graph_connections = dag.graph.copy()
+        # Let's come up with UUID node names
+        nodes = set(graph_connections.keys())
+        node_map = {name: f"{str(uuid4())}" for name in nodes}
+
+        # Construct the graph
+        def tree():
+            return defaultdict(tree)
+
+        graph: defaultdict = tree()
+
+        connections = ""
+        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
+
+            for sub in conns:
+                connections += f"{node_map[node]} --> {node_map[sub]}" + "\n"
+
+        # Now convert to dot syntax
+        def recurse_graph(g: defaultdict):
+            out = ""
+            for leaf in g:
+                if type(g[leaf]) == defaultdict:
+                    out += indent(
+                        "\n".join(
+                            [
+                                f"subgraph {leaf.lower()} [{leaf}]",
+                                # "direction LR",
+                                f"{recurse_graph(g[leaf])}",
+                                "end",
+                                "",
+                            ]
+                        ),
+                        IND,
+                    )
+                elif isinstance(g[leaf], str):
+                    out += indent(f"{node_map[g[leaf]]}[{leaf}]" + "\n", IND)
+            return out
+
+        subgraph_tree = recurse_graph(graph)
+
+        mermaid = "\n".join(
+            [
+                "flowchart LR",
+                subgraph_tree,
+                indent(connections, IND),
+            ]
+        )
+
+        # print(mermaid)
+        webbrowser.open(mm(mermaid))
+
+
+def mm(graph):
+    graphbytes = graph.encode("utf8")
+    base64_bytes = base64.b64encode(graphbytes)
+    base64_string = base64_bytes.decode("ascii")
+    return f"https://mermaid.ink/img/{base64_string}"