Simplify EventBus: default to synchronous dispatch

EventBus.publish() now dispatches directly when no wrapper is set,
eliminating the need for on_ready callbacks, log buffering, and
explicit registration in headless mode.

Author: pedjaradenkovic

event_bus.py

@@ -7,26 +7,11 @@
 class EventBus:
     def __init__(self):
         self._listeners: defaultdict[Type[BaseEvent], list[Callable[[Any], None]]] = defaultdict(list)
-        self._main_thread_callback: Callable[[Callable], None] | None = None
-        self._ready_callbacks: list[Callable[[], None]] = []
-
-    def register_main_thread_callback(self, fn: Callable[[Callable], None]):
-        """Set the function to call listeners from the main thread (e.g., Textual app.call_from_thread)."""
-        self._main_thread_callback = fn
-
-        # Notify anyone waiting for the event bus to be ready
-        for callback in self._ready_callbacks:
-            callback()
-        self._ready_callbacks.clear()
-
-    def on_ready(self, callback: Callable[[], None]):
-        """Register a callback to be called when the event bus is ready."""
-        if self._main_thread_callback:
-            # Already ready, call immediately
-            callback()
-        else:
-            # Not ready yet, queue it
-            self._ready_callbacks.append(callback)
+        self._dispatch_wrapper: Callable[[Callable], None] | None = None
+
+    def register_dispatch_wrapper(self, fn: Callable[[Callable], None]):
+        """Set a wrapper for dispatching listeners (e.g., Textual's app.call_from_thread)."""
+        self._dispatch_wrapper = fn
 
     def subscribe(self, event_type: Type[BaseEvent], listener: Callable[[Any], None]):
         """Registers a listener for a specific event type."""
@@ -39,7 +24,7 @@ def _dispatch():
             for listener in self._listeners[type(event)]:
                 listener(event)
 
-        if not self._main_thread_callback:
-            raise RuntimeError("No main thread callback set. Call register_main_thread_callback() first.")
-
-        self._main_thread_callback(_dispatch)
+        if self._dispatch_wrapper:
+            self._dispatch_wrapper(_dispatch)
+        else:
+            _dispatch()

plain2code.py

@@ -236,8 +236,6 @@ def render(args, run_state: RunState, event_bus: EventBus):  # noqa: C901
     )
 
     if args.headless:
-        # Dispatch events synchronously without a TUI.
-        event_bus.register_main_thread_callback(lambda fn: fn())
         # In headless mode, this will be the only output
         print(f"Render started. Render ID: {run_state.render_id}")
         module_renderer.render_module()

plain2code_logger.py

@@ -40,15 +40,10 @@ class TuiLoggingHandler(logging.Handler):
     def __init__(self, event_bus: EventBus):
         super().__init__()
         self.event_bus = event_bus
-        self._buffer = []
-        self.start_time = time.time()  # Record start time for offset calculation
-
-        # Register to be notified when event bus is ready
-        self.event_bus.on_ready(self._flush_buffer)
+        self.start_time = time.time()
 
     def emit(self, record):
         try:
-            # Extract structured data from the log record
             offset_seconds = record.created - self.start_time
             minutes = int(offset_seconds // 60)
             seconds = int(offset_seconds % 60)
@@ -60,28 +55,14 @@ def emit(self, record):
                 message=record.getMessage(),
                 timestamp=timestamp,
             )
-
-            # Try to publish, fall back to buffering if not ready
-            if self.event_bus._main_thread_callback:
-                self.event_bus.publish(event)
-            else:
-                self._buffer.append(event)
+            self.event_bus.publish(event)
         except RuntimeError:
             # We're going to get this crash after the TUI app is closed (forcefully).
             # NOTE: This should be more thought out.
             pass
         except Exception:
             self.handleError(record)
 
-    def _flush_buffer(self):
-        """Flush buffered log messages to the event bus."""
-        for event in self._buffer:
-            try:
-                self.event_bus.publish(event)
-            except Exception:
-                pass
-        self._buffer.clear()
-
 
 class CrashLogHandler(logging.Handler):
     def __init__(self):

tui/plain2code_tui.py

@@ -125,7 +125,7 @@ def get_active_script_types(self) -> list[ScriptOutputType]:
 
     def on_mount(self) -> None:
         """Called when the app is mounted."""
-        self.event_bus.register_main_thread_callback(self.call_from_thread)
+        self.event_bus.register_dispatch_wrapper(self.call_from_thread)
 
         self.event_bus.subscribe(RenderStateUpdated, self.on_render_state_updated)
         self.event_bus.subscribe(RenderCompleted, self.on_render_completed)