ezmsg 3.7.3__tar.gz → 3.9.0__tar.gz

{ezmsg-3.7.3 → ezmsg-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ezmsg
-Version: 3.7.3
+Version: 3.9.0
 Summary: A simple DAG-based computation model
 Author-email: Griffin Milsap <griffin.milsap@gmail.com>, Preston Peranich <pperanich@gmail.com>, Chadwick Boulay <chadwick.boulay@gmail.com>
 License: MIT License
@@ -20,6 +20,10 @@ Requires-Dist: array-api-compat>=1.12.0
 Requires-Dist: typing-extensions>=4.14.1
 Provides-Extra: axisarray
 Requires-Dist: numpy>=2.2.6; extra == 'axisarray'
+Provides-Extra: dashboard
+Requires-Dist: ezmsg-dashboard; (python_version >= '3.11') and extra == 'dashboard'
+Provides-Extra: perf
+Requires-Dist: xarray>=2025.6.1; extra == 'perf'
 Description-Content-Type: text/markdown
 
 # <img src="https://raw.githubusercontent.com/iscoe/ezmsg/main/docs/source/logo.png" width="50"/> ezmsg
@@ -119,4 +123,4 @@ These publications provide insights into the practical applications and impact o
  
 ## 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` is supported by Johns Hopkins University (JHU), the JHU Applied Physics Laboratory (APL), Blackrock Neurotech and by the Wyss Center for Bio and Neuro Engineering.

{ezmsg-3.7.3 → ezmsg-3.9.0}/README.md

@@ -95,4 +95,4 @@ These publications provide insights into the practical applications and impact o
  
 ## 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` is supported by Johns Hopkins University (JHU), the JHU Applied Physics Laboratory (APL), Blackrock Neurotech and by the Wyss Center for Bio and Neuro Engineering.

{ezmsg-3.7.3 → ezmsg-3.9.0}/docs/source/reference/API/functiondecorators.rst

@@ -11,6 +11,10 @@ These function decorators can be added to member functions of an ezmsg ``Unit``
 
 .. autodecorator:: ezmsg.core.thread
 
+.. note::
+   ``@ez.thread`` is deprecated and will be removed in a future release.
+   Prefer explicit background work via ``loop.run_in_executor(...)``.
+
 .. autodecorator:: ezmsg.core.task
 
 .. autodecorator:: ezmsg.core.process

{ezmsg-3.7.3 → ezmsg-3.9.0}/examples/ezmsg_configs.py

@@ -82,8 +82,8 @@ class Listener(ez.Unit):
 
 
 class PassthroughCollection(ez.Collection):
-    INPUT = ez.InputStream(int)
-    OUTPUT = ez.OutputStream(int)
+    INPUT = ez.InputTopic(int)
+    OUTPUT = ez.OutputTopic(int)
 
     def network(self) -> ez.NetworkDefinition:
         return ((self.INPUT, self.OUTPUT),)
@@ -136,7 +136,7 @@ class NoPubNoSubSystem(ez.Collection):
 
 
 class PubNoSubCollection(ez.Collection):
-    OUTPUT = ez.OutputStream(int)
+    OUTPUT = ez.OutputTopic(int)
     GENERATE = Generator()
     LOG = DebugLog()
 
@@ -148,7 +148,7 @@ class PubNoSubCollection(ez.Collection):
 
 
 class SubNoPubCollection(ez.Collection):
-    INPUT = ez.InputStream(int)
+    INPUT = ez.InputTopic(int)
     LISTEN = Listener()
 
     def network(self) -> ez.NetworkDefinition:
@@ -175,7 +175,7 @@ class PubNoSubPassthroughCollection(ez.Collection):
     COLLECTION = PubNoSubCollection()
     PASSTHROUGH = PassthroughCollection()
 
-    OUTPUT = ez.OutputStream(int)
+    OUTPUT = ez.OutputTopic(int)
 
     def network(self) -> ez.NetworkDefinition:
         return (
@@ -188,7 +188,7 @@ class SubNoPubPassthroughCollection(ez.Collection):
     COLLECTION = SubNoPubCollection()
     PASSTHROUGH = PassthroughCollection()
 
-    INPUT = ez.InputStream(int)
+    INPUT = ez.InputTopic(int)
 
     def network(self) -> ez.NetworkDefinition:
         return (

{ezmsg-3.7.3 → ezmsg-3.9.0}/examples/ezmsg_toy.py

@@ -24,20 +24,33 @@ class LFOSettings(ez.Settings):
     update_rate: float = 2.0  # Hz, update rate
 
 
+class LFOState(ez.State):
+    start_time: float
+    cur_settings: LFOSettings
+
+
 class LFO(ez.Unit):
     SETTINGS = LFOSettings
+    STATE = LFOState
 
     OUTPUT = ez.OutputStream(float)
 
+    INPUT_SETTINGS = ez.InputStream(LFOSettings)
+
     async def initialize(self) -> None:
-        self.start_time = time.time()
+        self.STATE.cur_settings = self.SETTINGS
+        self.STATE.start_time = time.time()
 
+    @ez.subscriber(INPUT_SETTINGS)
+    async def on_settings(self, msg: LFOSettings) -> None:
+        self.STATE.cur_settings = msg
+        
     @ez.publisher(OUTPUT)
     async def generate(self) -> AsyncGenerator:
         while True:
-            t = time.time() - self.start_time
-            yield self.OUTPUT, math.sin(2.0 * math.pi * self.SETTINGS.freq * t)
-            await asyncio.sleep(1.0 / self.SETTINGS.update_rate)
+            t = time.time() - self.STATE.start_time
+            yield self.OUTPUT, math.sin(2.0 * math.pi * self.STATE.cur_settings.freq * t)
+            await asyncio.sleep(1.0 / self.STATE.cur_settings.update_rate)
 
 
 # MESSAGE GENERATOR
@@ -45,17 +58,30 @@ class MessageGeneratorSettings(ez.Settings):
     message: str
 
 
+class MessageGeneratorState(ez.State):
+    cur_settings: MessageGeneratorSettings
+
+
 class MessageGenerator(ez.Unit):
     SETTINGS = MessageGeneratorSettings
+    STATE = MessageGeneratorState
 
     OUTPUT = ez.OutputStream(str)
+    INPUT_SETTINGS = ez.InputStream(MessageGeneratorSettings)
+
+    async def initialize(self) -> None:
+        self.STATE.cur_settings = self.SETTINGS
+
+    @ez.subscriber(INPUT_SETTINGS)
+    async def on_settings(self, msg: MessageGeneratorSettings) -> None:
+        self.STATE.cur_settings = msg
 
     @ez.publisher(OUTPUT)
     async def spawn_message(self) -> AsyncGenerator:
         while True:
             await asyncio.sleep(1.0)
-            ez.logger.info(f"Spawning {self.SETTINGS.message}")
-            yield self.OUTPUT, self.SETTINGS.message
+            ez.logger.info(f"Spawning {self.STATE.cur_settings.message}")
+            yield self.OUTPUT, self.STATE.cur_settings.message
 
     @ez.publisher(OUTPUT)
     async def spawn_once(self) -> AsyncGenerator:
@@ -123,8 +149,8 @@ class ModifierCollection(ez.Collection):
     """This collection will subscribe to messages
     and append the most recent LFO output"""
 
-    INPUT = ez.InputStream(str)
-    OUTPUT = ez.OutputStream(str)
+    INPUT = ez.InputTopic(str)
+    OUTPUT = ez.OutputTopic(str)
 
     SIN = LFO()
     # SIN2 = LFO()
@@ -152,6 +178,8 @@ class TestSystemSettings(ez.Settings):
 class TestSystem(ez.Collection):
     SETTINGS = TestSystemSettings
 
+    OUTPUT_PING = ez.OutputTopic(str)
+
     # Publishers
     PING = MessageGenerator()
     FOO = MessageGenerator()
@@ -173,6 +201,7 @@ class TestSystem(ez.Collection):
     # Define Connections
     def network(self) -> ez.NetworkDefinition:
         return (
+            (self.PING.OUTPUT, self.OUTPUT_PING),
             (self.PING.OUTPUT, self.PINGSUB1.INPUT),
             (self.PING.OUTPUT, self.MODIFIER_COLLECTION.INPUT),
             (self.MODIFIER_COLLECTION.OUTPUT, self.PINGSUB2.INPUT),
@@ -193,7 +222,7 @@ if __name__ == "__main__":
     ez.run(
         SYSTEM=system,
         connections=[
-            # Make PING.OUTPUT available on a topic ezmsg_attach.py
-            (system.PING.OUTPUT, "GLOBAL_PING_TOPIC"),
+            # Make a system output available on a topic ezmsg_attach.py
+            (system.OUTPUT_PING, "GLOBAL_PING_TOPIC"),
         ],
     )

ezmsg-3.9.0/examples/profiling_tui.py

@@ -0,0 +1,450 @@
+#!/usr/bin/env python3
+"""
+Simple live profiling TUI for ezmsg GraphServer.
+
+Features:
+- Periodic profiling snapshot view broken out by publisher/subscriber endpoints
+- Live trace sample counts via GraphContext.subscribe_profiling_trace()
+- Optional automatic trace enablement for discovered processes
+
+Usage:
+    .venv/bin/python examples/profiling_tui.py --host 127.0.0.1 --port 25978
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import contextlib
+import time
+from dataclasses import dataclass
+from uuid import UUID
+
+from ezmsg.core.graphcontext import GraphContext
+from ezmsg.core.graphmeta import (
+    ProcessProfilingSnapshot,
+    ProfilingStreamControl,
+    ProfilingTraceControl,
+)
+from ezmsg.core.netprotocol import DEFAULT_HOST, GRAPHSERVER_PORT_DEFAULT
+
+
+def _truncate(text: object, width: int) -> str:
+    text = str(text)
+    if width <= 3:
+        return text[:width]
+    if len(text) <= width:
+        return text
+    return text[: width - 3] + "..."
+
+
+def _fmt_float(value: float, digits: int = 2) -> str:
+    return f"{value:.{digits}f}"
+
+
+@dataclass
+class PublisherView:
+    process_id: UUID
+    topic: str
+    endpoint_id: str
+    published_total: int
+    published_window: int
+    publish_rate_hz: float
+    publish_delta_ms_avg: float
+    inflight_current: int
+    inflight_peak: int
+    trace_samples_seen: int
+    trace_last_age_s: float | None
+    backpressure_wait_ms_window: float
+
+
+@dataclass
+class SubscriberView:
+    process_id: UUID
+    topic: str
+    endpoint_id: str
+    channel_kind: str
+    received_total: int
+    received_window: int
+    lease_time_ms_avg: float
+    user_span_ms_avg: float
+    attributable_backpressure_ms_window: float
+    attributable_backpressure_events_total: int
+    trace_samples_seen: int
+    trace_last_age_s: float | None
+
+
+class ProfilingTUI:
+    def __init__(
+        self,
+        ctx: GraphContext,
+        *,
+        snapshot_interval: float,
+        trace_interval: float,
+        trace_max_samples: int,
+        auto_trace: bool,
+        trace_sample_mod: int,
+        max_rows: int,
+    ) -> None:
+        self.ctx = ctx
+        self.snapshot_interval = max(0.2, snapshot_interval)
+        self.trace_interval = max(0.01, trace_interval)
+        self.trace_max_samples = max(1, trace_max_samples)
+        self.auto_trace = auto_trace
+        self.trace_sample_mod = max(1, trace_sample_mod)
+        self.max_rows = max(5, max_rows)
+
+        self.snapshots: dict[UUID, ProcessProfilingSnapshot] = {}
+        self.route_units: dict[UUID, str] = {}
+        self.trace_enabled_processes: set[UUID] = set()
+        self.trace_errors: dict[UUID, str] = {}
+        self.trace_samples_seen_by_endpoint: dict[str, int] = {}
+        self.trace_last_timestamp_by_endpoint: dict[str, float] = {}
+        self.last_snapshot_time: float | None = None
+
+        self._snapshot_task: asyncio.Task[None] | None = None
+        self._trace_task: asyncio.Task[None] | None = None
+
+    async def start(self) -> None:
+        await self._refresh_snapshot()
+        self._snapshot_task = asyncio.create_task(self._snapshot_loop())
+        self._trace_task = asyncio.create_task(self._trace_loop())
+
+    async def close(self) -> None:
+        for task in (self._snapshot_task, self._trace_task):
+            if task is not None:
+                task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+
+        if not self.auto_trace:
+            return
+
+        for process_id, route_unit in self.route_units.items():
+            if process_id not in self.trace_enabled_processes:
+                continue
+            with contextlib.suppress(Exception):
+                await self.ctx.process_set_profiling_trace(
+                    route_unit,
+                    ProfilingTraceControl(enabled=False),
+                    timeout=0.5,
+                )
+
+    async def _snapshot_loop(self) -> None:
+        while True:
+            await self._refresh_snapshot()
+            await asyncio.sleep(self.snapshot_interval)
+
+    async def _refresh_snapshot(self) -> None:
+        graph_snapshot = await self.ctx.snapshot()
+        route_units: dict[UUID, str] = {}
+        for process in graph_snapshot.processes.values():
+            if process.units:
+                route_units[process.process_id] = process.units[0]
+        self.route_units = route_units
+
+        if self.auto_trace:
+            for process_id, route_unit in route_units.items():
+                if process_id in self.trace_enabled_processes:
+                    continue
+                try:
+                    response = await self.ctx.process_set_profiling_trace(
+                        route_unit,
+                        ProfilingTraceControl(
+                            enabled=True,
+                            sample_mod=self.trace_sample_mod,
+                        ),
+                        timeout=0.5,
+                    )
+                    if response.ok:
+                        self.trace_enabled_processes.add(process_id)
+                        self.trace_errors.pop(process_id, None)
+                    else:
+                        self.trace_errors[process_id] = str(
+                            response.error or "unknown error"
+                        )
+                except Exception as exc:
+                    self.trace_errors[process_id] = str(exc)
+
+        self.snapshots = await self.ctx.profiling_snapshot_all(
+            timeout_per_process=max(0.1, self.snapshot_interval * 0.8)
+        )
+        self.last_snapshot_time = time.time()
+
+    async def _trace_loop(self) -> None:
+        async for batch in self.ctx.subscribe_profiling_trace(
+            ProfilingStreamControl(
+                interval=self.trace_interval,
+                max_samples=self.trace_max_samples,
+            )
+        ):
+            for process_batch in batch.batches.values():
+                for sample in process_batch.samples:
+                    endpoint_id = sample.endpoint_id
+                    self.trace_samples_seen_by_endpoint[endpoint_id] = (
+                        self.trace_samples_seen_by_endpoint.get(endpoint_id, 0) + 1
+                    )
+                    self.trace_last_timestamp_by_endpoint[endpoint_id] = batch.timestamp
+
+    def _trace_for_endpoint(self, endpoint_id: str) -> tuple[int, float | None]:
+        now = time.time()
+        count = self.trace_samples_seen_by_endpoint.get(endpoint_id, 0)
+        ts = self.trace_last_timestamp_by_endpoint.get(endpoint_id)
+        age = None if ts is None else max(0.0, now - ts)
+        return count, age
+
+    def _publisher_rows(self) -> list[PublisherView]:
+        rows: list[PublisherView] = []
+        for process_id, snapshot in self.snapshots.items():
+            for pub in snapshot.publishers.values():
+                trace_count, trace_age = self._trace_for_endpoint(pub.endpoint_id)
+                rows.append(
+                    PublisherView(
+                        process_id=process_id,
+                        topic=pub.topic,
+                        endpoint_id=pub.endpoint_id,
+                        published_total=pub.messages_published_total,
+                        published_window=pub.messages_published_window,
+                        publish_rate_hz=pub.publish_rate_hz_window,
+                        publish_delta_ms_avg=pub.publish_delta_ns_avg_window / 1_000_000.0,
+                        inflight_current=pub.inflight_messages_current,
+                        inflight_peak=pub.inflight_messages_peak_window,
+                        trace_samples_seen=trace_count,
+                        trace_last_age_s=trace_age,
+                        backpressure_wait_ms_window=(
+                            pub.backpressure_wait_ns_window / 1_000_000.0
+                        ),
+                    )
+                )
+        rows.sort(
+            key=lambda row: (
+                -row.publish_rate_hz,
+                -row.published_total,
+                row.process_id,
+                row.topic,
+            )
+        )
+        return rows
+
+    def _subscriber_rows(self) -> list[SubscriberView]:
+        rows: list[SubscriberView] = []
+        for process_id, snapshot in self.snapshots.items():
+            for sub in snapshot.subscribers.values():
+                trace_count, trace_age = self._trace_for_endpoint(sub.endpoint_id)
+                channel_kind = (
+                    sub.channel_kind_last.value
+                    if hasattr(sub.channel_kind_last, "value")
+                    else str(sub.channel_kind_last)
+                )
+                rows.append(
+                    SubscriberView(
+                        process_id=process_id,
+                        topic=sub.topic,
+                        endpoint_id=sub.endpoint_id,
+                        channel_kind=channel_kind,
+                        received_total=sub.messages_received_total,
+                        received_window=sub.messages_received_window,
+                        lease_time_ms_avg=sub.lease_time_ns_avg_window / 1_000_000.0,
+                        user_span_ms_avg=sub.user_span_ns_avg_window / 1_000_000.0,
+                        attributable_backpressure_ms_window=(
+                            sub.attributable_backpressure_ns_window / 1_000_000.0
+                        ),
+                        attributable_backpressure_events_total=(
+                            sub.attributable_backpressure_events_total
+                        ),
+                        trace_samples_seen=trace_count,
+                        trace_last_age_s=trace_age,
+                    )
+                )
+        rows.sort(
+            key=lambda row: (
+                -row.lease_time_ms_avg,
+                -row.received_total,
+                row.process_id,
+                row.topic,
+            )
+        )
+        return rows
+
+    def render(self) -> None:
+        print("\x1bc", end="")
+        print("ezmsg profiling tui")
+        print("Ctrl-C to quit")
+        print(
+            "snapshot interval="
+            f"{self.snapshot_interval:.2f}s, trace interval={self.trace_interval:.2f}s, "
+            f"trace max_samples={self.trace_max_samples}, auto_trace={self.auto_trace}"
+        )
+        if self.last_snapshot_time is not None:
+            print(
+                "last snapshot age: "
+                f"{_fmt_float(max(0.0, time.time() - self.last_snapshot_time), 2)}s"
+            )
+        print(
+            f"processes discovered={len(self.route_units)} "
+            f"publishers={sum(len(s.publishers) for s in self.snapshots.values())} "
+            f"subscribers={sum(len(s.subscribers) for s in self.snapshots.values())}"
+        )
+
+        publisher_rows = self._publisher_rows()
+        subscriber_rows = self._subscriber_rows()
+
+        print("\nPublishers")
+        pub_header = (
+            f"{'Process':<20} {'Topic':<26} {'Endpoint':<24} "
+            f"{'Total':>8} {'Win':>6} {'RateHz':>8} {'DeltaMs':>8} "
+            f"{'InFl':>5} {'InPk':>5} {'BPmsW':>8} {'Trace':>7} {'TAge':>6}"
+        )
+        print(pub_header)
+        print("-" * len(pub_header))
+        if not publisher_rows:
+            print("<none>")
+        else:
+            for row in publisher_rows[: self.max_rows]:
+                trace_age = (
+                    "-" if row.trace_last_age_s is None else _fmt_float(row.trace_last_age_s, 2)
+                )
+                print(
+                    f"{_truncate(row.process_id, 20):<20} "
+                    f"{_truncate(row.topic, 26):<26} "
+                    f"{_truncate(row.endpoint_id, 24):<24} "
+                    f"{row.published_total:>8} "
+                    f"{row.published_window:>6} "
+                    f"{_fmt_float(row.publish_rate_hz, 2):>8} "
+                    f"{_fmt_float(row.publish_delta_ms_avg, 2):>8} "
+                    f"{row.inflight_current:>5} "
+                    f"{row.inflight_peak:>5} "
+                    f"{_fmt_float(row.backpressure_wait_ms_window, 2):>8} "
+                    f"{row.trace_samples_seen:>7} "
+                    f"{trace_age:>6}"
+                )
+
+        print("\nSubscribers")
+        sub_header = (
+            f"{'Process':<20} {'Topic':<26} {'Endpoint':<24} {'Kind':<6} "
+            f"{'Total':>8} {'Win':>6} {'LeaseMs':>8} {'UserMs':>8} "
+            f"{'BPmsW':>8} {'BPev':>6} {'Trace':>7} {'TAge':>6}"
+        )
+        print(sub_header)
+        print("-" * len(sub_header))
+        if not subscriber_rows:
+            print("<none>")
+        else:
+            for row in subscriber_rows[: self.max_rows]:
+                trace_age = (
+                    "-" if row.trace_last_age_s is None else _fmt_float(row.trace_last_age_s, 2)
+                )
+                print(
+                    f"{_truncate(row.process_id, 20):<20} "
+                    f"{_truncate(row.topic, 26):<26} "
+                    f"{_truncate(row.endpoint_id, 24):<24} "
+                    f"{_truncate(row.channel_kind, 6):<6} "
+                    f"{row.received_total:>8} "
+                    f"{row.received_window:>6} "
+                    f"{_fmt_float(row.lease_time_ms_avg, 2):>8} "
+                    f"{_fmt_float(row.user_span_ms_avg, 2):>8} "
+                    f"{_fmt_float(row.attributable_backpressure_ms_window, 2):>8} "
+                    f"{row.attributable_backpressure_events_total:>6} "
+                    f"{row.trace_samples_seen:>7} "
+                    f"{trace_age:>6}"
+                )
+
+        if self.trace_errors:
+            print("\ntrace errors:")
+            for process_id, err in sorted(self.trace_errors.items(), key=lambda item: str(item[0])):
+                print(f"  {_truncate(str(process_id), 30)}: {_truncate(err, 120)}")
+
+
+def _parse_address(host: str, port: int) -> tuple[str, int]:
+    return (host, port)
+
+
+async def _run_tui(args: argparse.Namespace) -> None:
+    async with GraphContext(
+        _parse_address(args.host, args.port), auto_start=args.auto_start
+    ) as ctx:
+        tui = ProfilingTUI(
+            ctx,
+            snapshot_interval=args.snapshot_interval,
+            trace_interval=args.trace_interval,
+            trace_max_samples=args.max_samples,
+            auto_trace=args.auto_trace,
+            trace_sample_mod=args.sample_mod,
+            max_rows=args.max_rows,
+        )
+        await tui.start()
+        try:
+            while True:
+                tui.render()
+                await asyncio.sleep(max(0.1, args.render_interval))
+        finally:
+            await tui.close()
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="ezmsg profiling TUI")
+    parser.add_argument("--host", default=DEFAULT_HOST, help="GraphServer host")
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=GRAPHSERVER_PORT_DEFAULT,
+        help="GraphServer port",
+    )
+    parser.add_argument(
+        "--auto-start",
+        action="store_true",
+        help="Allow GraphContext to auto-start GraphServer if unavailable",
+    )
+    parser.add_argument(
+        "--snapshot-interval",
+        type=float,
+        default=1.0,
+        help="Seconds between snapshot refreshes",
+    )
+    parser.add_argument(
+        "--trace-interval",
+        type=float,
+        default=0.02,
+        help="Seconds between GraphServer trace stream batches",
+    )
+    parser.add_argument(
+        "--max-samples",
+        type=int,
+        default=5000,
+        help="Max samples per process per streamed batch",
+    )
+    parser.add_argument(
+        "--sample-mod",
+        type=int,
+        default=1,
+        help="Trace sampling divisor when auto-enabling trace",
+    )
+    parser.add_argument(
+        "--render-interval",
+        type=float,
+        default=0.5,
+        help="Seconds between TUI redraws",
+    )
+    parser.add_argument(
+        "--max-rows",
+        type=int,
+        default=30,
+        help="Max publisher/subscriber rows to render per table",
+    )
+    parser.add_argument(
+        "--no-auto-trace",
+        action="store_true",
+        help="Do not auto-enable trace mode on discovered processes",
+    )
+    return parser
+
+
+def main() -> None:
+    parser = _build_parser()
+    args = parser.parse_args()
+    args.auto_trace = not args.no_auto_trace
+    asyncio.run(_run_tui(args))
+
+
+if __name__ == "__main__":
+    main()