Design

The application will be a single-window GUI built with PyQt5. It will be composed of three main components: a main
window, a refactored plotter widget, and a background worker for data acquisition.

 1 PicoStreamMainWindow (QMainWindow): This will be the application's central component, serving as the main entry point.
    • Layout: It will feature a two-panel layout. The left panel will contain all user-configurable settings for the
      acquisition (e.g., sample rate, voltage range, output file). The right panel will contain the embedded live plot.
    • Control: It will have "Start" and "Stop" buttons to manage the acquisition lifecycle. It will manage the
      application's state (e.g., idle, acquiring, error).
    • Persistence: It will use QSettings to automatically save user-entered settings on exit and load them on startup.
    • Lifecycle: It will be responsible for creating and managing the background worker thread and ensuring a graceful
      shutdown.
 2 HDF5LivePlotter (QWidget): The existing plotter will be refactored from a QMainWindow into a QWidget.
    • Responsibility: Its sole responsibility will be to monitor the HDF5 file and display the live data. It will no
      longer be a top-level window or control the application's lifecycle.
    • Integration: An instance of this widget will be created and embedded directly into the right-hand panel of the
      PicoStreamMainWindow.
 3 StreamerWorker (QObject): This class will manage the acquisition task in a background thread to keep the GUI
   responsive.
    • Execution: It will be moved to a QThread. Its primary method will instantiate the Streamer class with parameters
      from the GUI and call the blocking Streamer.run() method.
    • Communication: It will use Qt signals to report its status (e.g., finished, error) back to the PicoStreamMainWindow
      in a thread-safe manner. The main window will connect to these signals to update the UI, for example, by
      re-enabling the "Start" button upon completion.

                                               Phased Implementation Plan

This plan breaks the work into five distinct, sequential phases.

Phase 1: Project Restructuring and GUI Shell The goal is to set up the new file structure and a basic, non-functional GUI
window.

 1 Rename picostream/main.py to picostream/cli.py.
 2 Create a new, empty picostream/main.py to serve as the GUI entry point.
 3 In the new main.py, create a PicoStreamMainWindow class with a simple layout containing placeholders for the settings
   panel and the plot.
 4 Update the justfile with a new target to run the GUI application.

Phase 2: Background Worker Implementation The goal is to run the data acquisition in a background thread, controlled by
the GUI.

 1 In picostream/main.py, create the StreamerWorker class inheriting from QObject.
 2 Implement the QThread worker pattern in PicoStreamMainWindow to start the acquisition when a "Start" button is clicked
   and to signal a stop using the existing shutdown_event.
 3 Connect the worker's finished and error signals to GUI methods that update the UI state (e.g., re-enable buttons).

Phase 3: GUI Controls and Settings Persistence The goal is to make the acquisition configurable through the GUI and to
remember settings.

 1 Populate the settings panel in PicoStreamMainWindow with input widgets for all acquisition parameters.
 2 Pass the values from these widgets to the StreamerWorker when starting an acquisition.
 3 Implement load_settings and save_settings methods using QSettings.

Phase 4: Plotter Integration The goal is to embed the live plot directly into the main window.

 1 In picostream/dfplot.py, refactor the HDF5LivePlotter class to inherit from QWidget instead of QMainWindow. Remove its
   window-management logic.
 2 In PicoStreamMainWindow, replace the plot placeholder with an instance of the refactored HDF5LivePlotter widget.

Phase 5: Packaging The goal is to create a standalone, distributable executable.

 1 Add a new build target to the justfile that uses PyInstaller to bundle the application.
 2 Configure the build to handle dependencies, particularly creating a hook for Numba if necessary.
 3 Test the final executable.