aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.gitignore3
-rw-r--r--justfile12
-rw-r--r--new_plan.md65
-rw-r--r--picostream/cli.py647
-rw-r--r--picostream/dfplot.py38
-rw-r--r--picostream/main.py876
-rw-r--r--uv.lock268
7 files changed, 1264 insertions, 645 deletions
diff --git a/.gitignore b/.gitignore
index a7c3d30..8d381ec 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,6 @@ output.hdf5
complexipy.json
build/*
*egg-info*
+
+*.spec
+dist/
diff --git a/justfile b/justfile
new file mode 100644
index 0000000..478f4f3
--- /dev/null
+++ b/justfile
@@ -0,0 +1,12 @@
+set windows-shell := ["C:\\Program Files\\Git\\bin\\sh.exe","-c"]
+
+
+# Run the picostream GUI application
+gui:
+ PYTHONPATH=. uv run picostream/main.py
+
+# Build the picostream GUI executable
+build-gui:
+ uv pip install pyinstaller pyinstaller-hooks-contrib
+ uv run pyinstaller --onefile --windowed --name PicoStream picostream/main.py
+
diff --git a/new_plan.md b/new_plan.md
new file mode 100644
index 0000000..6c7186e
--- /dev/null
+++ b/new_plan.md
@@ -0,0 +1,65 @@
+ 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.
diff --git a/picostream/cli.py b/picostream/cli.py
new file mode 100644
index 0000000..fa72518
--- /dev/null
+++ b/picostream/cli.py
@@ -0,0 +1,647 @@
+from __future__ import annotations
+
+import queue
+import signal
+import sys
+import threading
+import time
+from datetime import datetime
+from typing import TYPE_CHECKING, List, Optional
+
+if TYPE_CHECKING:
+ from PyQt5.QtWidgets import QApplication
+
+import click
+import h5py
+import numpy as np
+from loguru import logger
+
+from . import __version__
+from .consumer import Consumer
+from .pico import PicoDevice
+
+
+class Streamer:
+ """Orchestrates the Picoscope data acquisition process.
+
+ This class initializes the Picoscope device (producer), the HDF5 writer
+ (consumer), and the live plotter. It manages the threads, queues, and
+ graceful shutdown of the entire application.
+
+ Supports both standard acquisition mode (saves all data) and live-only mode
+ (limits buffer size using max_buffer_seconds parameter).
+ """
+
+ def __init__(
+ self,
+ sample_rate_msps: float = 62.5,
+ resolution_bits: int = 12,
+ channel_range_str: str = "PS5000A_20V",
+ enable_live_plot: bool = False,
+ output_file: str = "./output.hdf5",
+ debug: bool = False,
+ plot_window_s: float = 0.5,
+ plot_points: int = 4000,
+ hardware_downsample: int = 1,
+ downsample_mode: str = "average",
+ offset_v: float = 0.0,
+ max_buffer_seconds: Optional[float] = None,
+ ) -> None:
+ # --- Configuration ---
+ self.output_file = output_file
+ self.debug = debug
+ self.enable_live_plot = enable_live_plot
+ self.plot_window_s = plot_window_s
+ self.max_buffer_seconds = max_buffer_seconds
+
+ (
+ sample_rate_msps,
+ pico_downsample_ratio,
+ pico_ratio_mode,
+ offset_v,
+ ) = self._validate_config(
+ resolution_bits,
+ sample_rate_msps,
+ channel_range_str,
+ hardware_downsample,
+ downsample_mode,
+ offset_v,
+ )
+ # Dynamically size buffers to hold a specific duration of data. This makes
+ # memory usage proportional to the data rate, providing a consistent
+ # time-based buffer to handle processing latencies.
+ effective_rate_sps = (sample_rate_msps * 1e6) / pico_downsample_ratio
+
+ # Consumer buffers (for writing to HDF5) are sized to hold 1 second of data.
+ # This is a good balance, as larger buffers lead to more efficient disk writes
+ # but use more RAM.
+ consumer_buffer_duration_s = 1.0
+ self.consumer_buffer_size = int(
+ effective_rate_sps * consumer_buffer_duration_s
+ )
+ if downsample_mode == "aggregate":
+ self.consumer_buffer_size *= 2
+ self.consumer_num_buffers = 5 # A pool of 5 buffers
+
+ # The Picoscope driver buffer is sized to hold 0.5 seconds of data. This
+ # buffer receives data directly from the hardware. A smaller size ensures
+ # that the application receives data in timely chunks, reducing latency.
+ driver_buffer_duration_s = 0.5
+ self.pico_driver_buffer_size = int(
+ effective_rate_sps * driver_buffer_duration_s
+ )
+ self.pico_driver_num_buffers = (
+ 1 # A single large buffer is efficient for the driver
+ )
+
+ logger.info(
+ f"Consumer buffer sized to {self.consumer_buffer_size:,} samples "
+ f"({consumer_buffer_duration_s}s at effective rate)"
+ )
+ logger.info(
+ f"Pico driver buffer sized to {self.pico_driver_buffer_size:,} samples "
+ f"({driver_buffer_duration_s}s at effective rate)"
+ )
+
+ # --- Plotting Decimation ---
+ # Calculate the decimation factor needed to achieve the target number of plot points.
+ points_per_timestep = 2 if downsample_mode == "aggregate" else 1
+ samples_in_window = effective_rate_sps * plot_window_s * points_per_timestep
+ self.decimation_factor = max(1, int(samples_in_window / plot_points))
+ logger.info(
+ f"Plotting with target of {plot_points} points. "
+ f"Calculated decimation factor: {self.decimation_factor}"
+ )
+
+ # Picoscope hardware settings
+ self.pico_resolution = f"PS5000A_DR_{resolution_bits}BIT"
+ self.pico_channel_range = channel_range_str
+ self.pico_sample_interval_ns = int(1000 / sample_rate_msps)
+ self.pico_sample_unit = "PS5000A_NS"
+
+ # Streaming settings
+ self.pico_auto_stop = 0 # Don't auto stop
+ self.pico_auto_stop_stream = False
+ # --- End Configuration ---
+
+ # --- System Components ---
+ self.shutdown_event: threading.Event = threading.Event()
+ data_queue: queue.Queue[int] = queue.Queue()
+ empty_queue: queue.Queue[int] = queue.Queue()
+ data_buffers: List[np.ndarray] = []
+
+ # Pre-allocate a pool of numpy arrays for data transfer and populate the
+ # empty_queue with their indices.
+ for idx in range(self.consumer_num_buffers):
+ data_buffers.append(np.empty((self.consumer_buffer_size,), dtype="int16"))
+ empty_queue.put(idx)
+
+ # --- Producer ---
+ self.pico_device: PicoDevice = PicoDevice(
+ 0, # handle
+ self.pico_resolution,
+ self.pico_driver_buffer_size,
+ self.pico_driver_num_buffers,
+ self.consumer_buffer_size,
+ data_queue,
+ empty_queue,
+ data_buffers,
+ self.shutdown_event,
+ downsample_mode=downsample_mode,
+ )
+
+ self.pico_device.set_channel(
+ "PS5000A_CHANNEL_A", 1, "PS5000A_DC", self.pico_channel_range, offset_v
+ )
+ self.pico_device.set_channel(
+ "PS5000A_CHANNEL_B", 0, "PS5000A_DC", self.pico_channel_range, 0.0
+ )
+ self.pico_device.set_data_buffer("PS5000A_CHANNEL_A", 0, pico_ratio_mode)
+ self.pico_device.configure_streaming_var(
+ self.pico_sample_interval_ns,
+ self.pico_sample_unit,
+ 0, # pre-trigger samples
+ pico_downsample_ratio,
+ pico_ratio_mode,
+ self.pico_auto_stop,
+ self.pico_auto_stop_stream,
+ )
+
+ # Run streaming once to get the actual sample interval from the driver
+ self.pico_device.run_streaming()
+
+ # --- Consumer ---
+ # Prepare metadata for the consumer
+ acquisition_start_time_utc = datetime.utcnow().isoformat() + "Z"
+ was_live_mode = self.max_buffer_seconds is not None
+
+ # Get metadata from configured device and pass to consumer
+ metadata = self.pico_device.get_metadata(
+ acquisition_start_time_utc=acquisition_start_time_utc,
+ picostream_version=__version__,
+ acquisition_command="", # Will be set later in main()
+ was_live_mode=was_live_mode
+ )
+
+ # Calculate max samples for live-only mode
+ max_samples = None
+ if self.max_buffer_seconds:
+ max_samples = int(effective_rate_sps * self.max_buffer_seconds)
+ if downsample_mode == "aggregate":
+ max_samples *= 2
+ logger.info(f"Live-only mode: limiting buffer to {self.max_buffer_seconds}s ({max_samples:,} samples)")
+
+ self.consumer: Consumer = Consumer(
+ self.consumer_buffer_size,
+ data_queue,
+ empty_queue,
+ data_buffers,
+ output_file,
+ self.shutdown_event,
+ metadata=metadata,
+ max_samples=max_samples,
+ )
+
+ # --- Threads ---
+ self.consumer_thread: threading.Thread = threading.Thread(
+ target=self.consumer.consume
+ )
+ self.pico_thread: threading.Thread = threading.Thread(
+ target=self.pico_device.run_capture
+ )
+
+ # --- Signal Handling ---
+ # Only set the signal handler if not in GUI mode.
+ # In GUI mode, the main function will handle signals to quit the Qt app.
+ if not self.enable_live_plot:
+ signal.signal(signal.SIGINT, self.signal_handler)
+
+ # --- Live Plotting (optional) ---
+ self.start_time: Optional[float] = None
+
+ def update_acquisition_command(self, command: str) -> None:
+ """Update the acquisition command in the consumer's metadata."""
+ self.consumer.metadata["acquisition_command"] = command
+
+ def _validate_config(
+ self,
+ resolution_bits: int,
+ sample_rate_msps: float,
+ channel_range_str: str,
+ hardware_downsample: int,
+ downsample_mode: str,
+ offset_v: float,
+ ) -> tuple[float, int, str, float]:
+ """Validates user-provided settings and returns derived configuration."""
+ if resolution_bits == 8:
+ max_rate_msps = 125.0
+ elif resolution_bits in [12, 14, 15, 16]:
+ max_rate_msps = 62.5
+ else:
+ raise ValueError(
+ f"Unsupported resolution: {resolution_bits} bits. Must be one of 8, 12, 14, 15, 16."
+ )
+
+ if sample_rate_msps <= 0:
+ sample_rate_msps = max_rate_msps
+ logger.info(f"Max sample rate requested. Setting to {max_rate_msps} MS/s.")
+
+ if sample_rate_msps > max_rate_msps:
+ raise ValueError(
+ f"Sample rate {sample_rate_msps} MS/s exceeds maximum of {max_rate_msps} MS/s for {resolution_bits}-bit resolution."
+ )
+
+ # Check if sample rate is excessive for the analog bandwidth.
+ # Bandwidth is dependent on both resolution and voltage range.
+ # (Based on PicoScope 5000A/B Series datasheet)
+ inv_voltage_map = {v: k for k, v in VOLTAGE_RANGE_MAP.items()}
+ voltage_v = inv_voltage_map.get(channel_range_str, 0)
+
+ if resolution_bits == 16:
+ bandwidth_mhz = 20 # 20 MHz for all ranges
+ elif resolution_bits == 15:
+ # Bandwidth is 70MHz for < ±5V, 60MHz for >= ±5V
+ bandwidth_mhz = 70 if voltage_v < 5.0 else 60
+ else: # 8-14 bits
+ # Bandwidth is 100MHz for < ±5V, 60MHz for >= ±5V
+ bandwidth_mhz = 100 if voltage_v < 5.0 else 60
+
+ # Nyquist rate is 2x bandwidth. A common rule of thumb is 3-5x.
+ # Warn if sampling faster than 5x the analog bandwidth.
+ if sample_rate_msps > 5 * bandwidth_mhz:
+ logger.warning(
+ f"Sample rate ({sample_rate_msps} MS/s) may be unnecessarily high "
+ f"for the selected voltage range ({channel_range_str}), which has an "
+ f"analog bandwidth of {bandwidth_mhz} MHz."
+ )
+
+ if downsample_mode == "aggregate" and hardware_downsample <= 1:
+ raise ValueError(
+ "Hardware downsample ratio must be > 1 for 'aggregate' mode."
+ )
+
+ if hardware_downsample > 1:
+ pico_downsample_ratio = hardware_downsample
+ pico_ratio_mode = f"PS5000A_RATIO_MODE_{downsample_mode.upper()}"
+ logger.info(
+ f"Hardware down-sampling ({downsample_mode}) enabled "
+ + f"with ratio {pico_downsample_ratio}."
+ )
+ else:
+ pico_downsample_ratio = 1
+ pico_ratio_mode = "PS5000A_RATIO_MODE_NONE"
+
+ # Validate analog offset
+ if offset_v != 0.0:
+ if voltage_v >= 5.0:
+ raise ValueError(
+ f"Analog offset is not supported for voltage ranges >= 5V (selected: {channel_range_str})."
+ )
+ if abs(offset_v) > voltage_v:
+ raise ValueError(
+ f"Analog offset ({offset_v}V) exceeds the selected voltage range (±{voltage_v}V)."
+ )
+ logger.info(f"Analog offset set to {offset_v:.3f}V.")
+
+ return sample_rate_msps, pico_downsample_ratio, pico_ratio_mode, offset_v
+
+ def signal_handler(self, _sig: int, frame: Optional[object]) -> None:
+ """Handles Ctrl+C interrupts to initiate a graceful shutdown."""
+ logger.warning("Ctrl+C detected. Shutting down.")
+ self.shutdown()
+
+ def shutdown(self) -> None:
+ """Performs a graceful shutdown of all components.
+
+ This method calculates final statistics, stops all threads, closes the
+ plotter, and ensures the Picoscope device is properly closed.
+ """
+ if self.shutdown_event.is_set():
+ return
+
+ self._log_acquisition_summary()
+ self.shutdown_event.set()
+
+ logger.info("Stopping data acquisition and saving...")
+
+ self._join_threads()
+ self.pico_device.close_device()
+
+ logger.success("Shutdown complete.")
+
+ def _log_acquisition_summary(self) -> None:
+ """Calculates and logs final acquisition statistics."""
+ if not self.start_time:
+ return
+
+ end_time = time.time()
+ duration = end_time - self.start_time
+ total_samples = self.consumer.values_written
+ effective_rate_msps = (total_samples / duration) / 1e6 if duration > 0 else 0
+ configured_rate_msps = 1e3 / self.pico_device.sample_int.value
+
+ logger.info("--- Acquisition Summary ---")
+ logger.info(f"Total acquisition time: {duration:.2f} s")
+ logger.info(
+ "Total samples written: "
+ + f"{self.consumer.format_sample_count(total_samples)}"
+ )
+ logger.info(f"Configured sample rate: {configured_rate_msps:.2f} MS/s")
+ logger.info(f"Effective average rate: {effective_rate_msps:.2f} MS/s")
+
+ rate_ratio = (
+ effective_rate_msps / configured_rate_msps
+ if configured_rate_msps > 0
+ else 0
+ )
+ if rate_ratio < 0.95:
+ logger.warning(
+ f"Effective rate was only {rate_ratio:.1%} " + "of the configured rate."
+ )
+ else:
+ logger.success("Effective rate matches configured rate.")
+ logger.info("--------------------------")
+
+ def _join_threads(self) -> None:
+ """Waits for the producer and consumer threads to terminate."""
+ for thread_name in ["pico_thread", "consumer_thread"]:
+ thread = getattr(self, thread_name, None)
+ if thread and thread.is_alive():
+ logger.info(f"Waiting for {thread_name} to terminate...")
+ thread.join(timeout=2.0)
+ if thread.is_alive():
+ logger.critical(f"{thread_name} failed to terminate.")
+
+ def run(self, app: Optional[QApplication] = None) -> None:
+ """Starts the acquisition threads and optionally the Qt event loop."""
+ # Start acquisition threads
+ self.start_time = time.time()
+ self.consumer_thread.start()
+ self.pico_thread.start()
+
+ # Handle Qt event loop if plotting is enabled
+ if self.enable_live_plot and app:
+ from .dfplot import HDF5LivePlotter
+
+ plotter = HDF5LivePlotter(
+ hdf5_path=self.output_file,
+ display_window_seconds=self.plot_window_s,
+ decimation_factor=self.decimation_factor,
+ shutdown_event=self.shutdown_event,
+ )
+ plotter.show()
+
+ # Run the Qt event loop. This will block until the plot window is closed.
+ app.exec_()
+
+ # Once the window is closed, the shutdown event should have been set.
+ # We call shutdown() to ensure threads are joined and cleanup happens.
+ self.shutdown()
+ else:
+ # Original non-GUI behavior
+ self.consumer_thread.join()
+ self.pico_thread.join()
+ logger.success("Acquisition complete!")
+
+
+# --- Argument Parsing ---
+VOLTAGE_RANGE_MAP = {
+ 0.01: "PS5000A_10MV",
+ 0.02: "PS5000A_20MV",
+ 0.05: "PS5000A_50MV",
+ 0.1: "PS5000A_100MV",
+ 0.2: "PS5000A_200MV",
+ 0.5: "PS5000A_500MV",
+ 1: "PS5000A_1V",
+ 2: "PS5000A_2V",
+ 5: "PS5000A_5V",
+ 10: "PS5000A_10V",
+ 20: "PS5000A_20V",
+}
+
+
+def generate_unique_filename(base_path: str) -> str:
+ """Generate a unique filename by appending timestamp if file exists."""
+ import os
+ from pathlib import Path
+
+ if not os.path.exists(base_path):
+ return base_path
+
+ # Split the path into parts
+ path = Path(base_path)
+ stem = path.stem
+ suffix = path.suffix
+ parent = path.parent
+
+ # Generate timestamp
+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+ # Create new filename with timestamp
+ new_filename = f"{stem}_{timestamp}{suffix}"
+ new_path = parent / new_filename
+
+ return str(new_path)
+
+
+@click.command()
+@click.option(
+ "--sample-rate",
+ "-s",
+ type=float,
+ default=20,
+ help="Sample rate in MS/s (e.g., 62.5). Use 0 for max rate. [default: 20]",
+)
+@click.option(
+ "--resolution",
+ "-b",
+ type=click.Choice(["8", "12", "16"]),
+ default="12",
+ help="Resolution in bits. [default: 12]",
+)
+@click.option(
+ "--rangev",
+ "-r",
+ type=click.Choice([str(k) for k in sorted(VOLTAGE_RANGE_MAP.keys())]),
+ default="20",
+ help=f"Voltage range in Volts. [default: 20]",
+)
+@click.option(
+ "--plot/--no-plot",
+ "-p",
+ is_flag=True,
+ default=True,
+ help="Enable/disable live plotting. [default: --plot]",
+)
+@click.option(
+ "--output",
+ "-o",
+ type=click.Path(dir_okay=False, writable=True),
+ help="Output HDF5 file (default: auto-timestamped).",
+)
+@click.option(
+ "--plot-window",
+ "-w",
+ type=float,
+ default=0.5,
+ help="Live plot display window duration in seconds. [default: 0.5]",
+)
+@click.option(
+ "--verbose", "-v", is_flag=True, default=False, help="Enable debug logging."
+)
+@click.option(
+ "--plot-npts",
+ "-n",
+ type=int,
+ default=4000,
+ help="Target number of points for the plot window. [default: 4000]",
+)
+@click.option(
+ "--hardware-downsample",
+ "-h",
+ type=int,
+ default=1,
+ help="Hardware down-sampling ratio (power of 2 for 'average' mode). [default: 1]",
+)
+@click.option(
+ "--downsample-mode",
+ "-m",
+ type=click.Choice(["average", "aggregate"]),
+ default="average",
+ help="Hardware down-sampling mode. [default: average]",
+)
+@click.option(
+ "--offset",
+ type=float,
+ default=0.0,
+ help="Analog offset in Volts (only for ranges < 5V). [default: 0.0]",
+)
+@click.option(
+ "--max-buff-sec",
+ type=float,
+ help="Maximum buffer duration in seconds for live-only mode (limits file size).",
+)
+@click.option(
+ "--force",
+ "-f",
+ is_flag=True,
+ default=False,
+ help="Overwrite existing output file.",
+)
+def main(
+ sample_rate: float,
+ resolution: str,
+ rangev: str,
+ plot: bool,
+ output: Optional[str],
+ plot_window: float,
+ verbose: bool,
+ plot_npts: int,
+ hardware_downsample: int,
+ downsample_mode: str,
+ offset: float,
+ max_buff_sec: Optional[float],
+ force: bool,
+) -> None:
+ """High-speed data acquisition tool for Picoscope 5000a series."""
+ # --- Argument Validation and Processing ---
+ channel_range_str = VOLTAGE_RANGE_MAP[float(rangev)]
+ resolution_bits = int(resolution)
+
+ app: Optional[QApplication] = None
+ if plot:
+ from PyQt5.QtWidgets import QApplication
+
+ app = QApplication(sys.argv)
+
+ # When plotting, SIGINT should gracefully close the Qt application.
+ # The main loop will then handle the shutdown.
+ def sigint_handler(_sig: int, _frame: Optional[object]) -> None:
+ logger.warning("Ctrl+C detected. Closing application.")
+ QApplication.quit()
+
+ signal.signal(signal.SIGINT, sigint_handler)
+
+ # Configure logging
+ logger.remove()
+ log_level = "DEBUG" if verbose else "INFO"
+ logger.add(sys.stderr, level=log_level)
+ logger.info(f"Logging configured at level: {log_level}")
+
+ # Auto-generate filename if not specified
+ if not output:
+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+ output = f"./output_{timestamp}.hdf5"
+ else:
+ # Check if file exists and handle accordingly
+ if not force:
+ original_output = output
+ output = generate_unique_filename(output)
+ if output != original_output:
+ logger.info(f"File '{original_output}' exists. Using '{output}' instead.")
+ logger.info("Use --force/-f to overwrite existing files.")
+
+ logger.info(f"Output file: {output}")
+ logger.info(f"Selected voltage range: {rangev}V -> {channel_range_str}")
+
+ try:
+ # Create and run the streamer
+ streamer = Streamer(
+ sample_rate_msps=sample_rate,
+ resolution_bits=resolution_bits,
+ channel_range_str=channel_range_str,
+ enable_live_plot=plot,
+ output_file=output,
+ debug=verbose,
+ plot_window_s=plot_window,
+ plot_points=plot_npts,
+ hardware_downsample=hardware_downsample,
+ downsample_mode=downsample_mode,
+ offset_v=offset,
+ max_buffer_seconds=max_buff_sec,
+ )
+
+ # Update the acquisition command in metadata
+ acquisition_command = " ".join(sys.argv)
+ streamer.update_acquisition_command(acquisition_command)
+
+ streamer.run(app)
+ except RuntimeError as e:
+ if "PICO_NOT_FOUND" in str(e):
+ logger.critical(
+ "Picoscope device not found. Please check connection and ensure no other software is using it."
+ )
+ else:
+ logger.critical(f"Failed to initialize Picoscope: {e}")
+ sys.exit(1)
+
+ # --- Verification Step ---
+ # Skip verification in live-only mode since file size is limited
+ if not streamer.max_buffer_seconds:
+ logger.info(f"Verifying output file: {output}")
+ try:
+ expected_samples = streamer.consumer.values_written
+ if expected_samples == 0:
+ logger.warning("Consumer processed no samples. Nothing to verify.")
+ else:
+ with h5py.File(output, "r") as f:
+ if "adc_counts" not in f:
+ raise ValueError("Dataset 'adc_counts' not found in HDF5 file.")
+
+ actual_samples = len(f["adc_counts"])
+ if actual_samples == expected_samples:
+ logger.success(
+ f"Verification PASSED: File contains {actual_samples} samples, as expected."
+ )
+ else:
+ logger.error(
+ f"Verification FAILED: Expected {expected_samples} samples, but file has {actual_samples}."
+ )
+ except Exception as e:
+ logger.error(f"HDF5 file verification failed: {e}")
+ else:
+ logger.info("Skipping verification in live-only mode.")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/picostream/dfplot.py b/picostream/dfplot.py
index 50c1cba..89784ac 100644
--- a/picostream/dfplot.py
+++ b/picostream/dfplot.py
@@ -16,7 +16,6 @@ from PyQt5.QtWidgets import (
QApplication,
QHBoxLayout,
QLabel,
- QMainWindow,
QVBoxLayout,
QWidget,
)
@@ -24,7 +23,7 @@ from PyQt5.QtWidgets import (
from .conversion_utils import adc_to_mV, min_max_decimate_numba
-class HDF5LivePlotter(QMainWindow):
+class HDF5LivePlotter(QWidget):
"""
Real-time oscilloscope-style plotter that reads from HDF5 files.
Completely independent of acquisition system for zero-risk operation.
@@ -39,7 +38,6 @@ class HDF5LivePlotter(QMainWindow):
update_interval_ms: int = 50,
display_window_seconds: float = 0.5,
decimation_factor: int = 150,
- shutdown_event: Optional[threading.Event] = None,
) -> None:
"""Initializes the HDF5LivePlotter window.
@@ -48,7 +46,6 @@ class HDF5LivePlotter(QMainWindow):
update_interval_ms: How often to check the file for updates (in ms).
display_window_seconds: The time duration of data to display.
decimation_factor: The factor by which to decimate data for plotting.
- shutdown_event: An event to signal graceful shutdown to the main application.
"""
super().__init__()
@@ -57,7 +54,6 @@ class HDF5LivePlotter(QMainWindow):
self.update_interval_ms: int = update_interval_ms
self.display_window_seconds: float = display_window_seconds
self.decimation_factor: int = decimation_factor
- self.shutdown_event: Optional[threading.Event] = shutdown_event
# --- UI State ---
self.heartbeat_chars: List[str] = ["|", "/", "-", "\\"]
@@ -121,15 +117,26 @@ class HDF5LivePlotter(QMainWindow):
# Initial file check
self.check_file_exists()
+ def set_hdf5_path(self, hdf5_path: str) -> None:
+ """Sets the HDF5 file path to monitor and resets the plot."""
+ self.hdf5_path = hdf5_path
+ logger.info(f"Plotter path updated to: {hdf5_path}")
+ # Reset state
+ self.display_data = np.array([])
+ self.time_data = np.array([])
+ self.data_start_sample = 0
+ self.last_file_size = 0
+ self.buffer_reset_count = 0
+ self.total_samples_processed = 0
+ self.rate_check_start_time = None
+ self.last_displayed_size = 0
+ self.curve.setData([], []) # Clear plot
+ self.check_file_exists()
+
def setup_ui(self) -> None:
"""Sets up the main window, widgets, and plot layout."""
- self.setWindowTitle("PicoScope Live Plotter - HDF5 Reader")
- self.setGeometry(100, 100, 1200, 800)
-
- # Central widget
- central_widget = QWidget()
- self.setCentralWidget(central_widget)
- layout = QVBoxLayout(central_widget)
+ layout = QVBoxLayout(self)
+ layout.setContentsMargins(0, 0, 0, 0)
# Status bar
status_layout = QHBoxLayout()
@@ -583,6 +590,8 @@ class HDF5LivePlotter(QMainWindow):
def save_screenshot(self) -> None:
"""Save a screenshot of the current plot."""
try:
+ import pyqtgraph.exporters
+
timestamp = time.strftime("%Y%m%d_%H%M%S")
filename = f"plot_screenshot_{timestamp}.png"
@@ -622,10 +631,7 @@ class HDF5LivePlotter(QMainWindow):
def keyPressEvent(self, event: QKeyEvent) -> None:
"""Handles key presses for application control (e.g., 'Q' to quit)."""
- if event.key() == Qt.Key_Q:
- logger.info("'Q' key pressed. Closing application.")
- self.close()
- elif event.key() in (Qt.Key_S, Qt.Key_Space, Qt.Key_F12):
+ if event.key() in (Qt.Key_S, Qt.Key_Space, Qt.Key_F12):
logger.info("Screenshot key pressed. Saving screenshot.")
self.save_screenshot()
else:
diff --git a/picostream/main.py b/picostream/main.py
index fa72518..b2f03b4 100644
--- a/picostream/main.py
+++ b/picostream/main.py
@@ -1,646 +1,264 @@
-from __future__ import annotations
-import queue
-import signal
+
import sys
-import threading
-import time
-from datetime import datetime
-from typing import TYPE_CHECKING, List, Optional
-
-if TYPE_CHECKING:
- from PyQt5.QtWidgets import QApplication
-
-import click
-import h5py
-import numpy as np
-from loguru import logger
-
-from . import __version__
-from .consumer import Consumer
-from .pico import PicoDevice
-
-
-class Streamer:
- """Orchestrates the Picoscope data acquisition process.
-
- This class initializes the Picoscope device (producer), the HDF5 writer
- (consumer), and the live plotter. It manages the threads, queues, and
- graceful shutdown of the entire application.
-
- Supports both standard acquisition mode (saves all data) and live-only mode
- (limits buffer size using max_buffer_seconds parameter).
- """
-
- def __init__(
- self,
- sample_rate_msps: float = 62.5,
- resolution_bits: int = 12,
- channel_range_str: str = "PS5000A_20V",
- enable_live_plot: bool = False,
- output_file: str = "./output.hdf5",
- debug: bool = False,
- plot_window_s: float = 0.5,
- plot_points: int = 4000,
- hardware_downsample: int = 1,
- downsample_mode: str = "average",
- offset_v: float = 0.0,
- max_buffer_seconds: Optional[float] = None,
- ) -> None:
- # --- Configuration ---
- self.output_file = output_file
- self.debug = debug
- self.enable_live_plot = enable_live_plot
- self.plot_window_s = plot_window_s
- self.max_buffer_seconds = max_buffer_seconds
-
- (
- sample_rate_msps,
- pico_downsample_ratio,
- pico_ratio_mode,
- offset_v,
- ) = self._validate_config(
- resolution_bits,
- sample_rate_msps,
- channel_range_str,
- hardware_downsample,
- downsample_mode,
- offset_v,
- )
- # Dynamically size buffers to hold a specific duration of data. This makes
- # memory usage proportional to the data rate, providing a consistent
- # time-based buffer to handle processing latencies.
- effective_rate_sps = (sample_rate_msps * 1e6) / pico_downsample_ratio
-
- # Consumer buffers (for writing to HDF5) are sized to hold 1 second of data.
- # This is a good balance, as larger buffers lead to more efficient disk writes
- # but use more RAM.
- consumer_buffer_duration_s = 1.0
- self.consumer_buffer_size = int(
- effective_rate_sps * consumer_buffer_duration_s
- )
- if downsample_mode == "aggregate":
- self.consumer_buffer_size *= 2
- self.consumer_num_buffers = 5 # A pool of 5 buffers
-
- # The Picoscope driver buffer is sized to hold 0.5 seconds of data. This
- # buffer receives data directly from the hardware. A smaller size ensures
- # that the application receives data in timely chunks, reducing latency.
- driver_buffer_duration_s = 0.5
- self.pico_driver_buffer_size = int(
- effective_rate_sps * driver_buffer_duration_s
- )
- self.pico_driver_num_buffers = (
- 1 # A single large buffer is efficient for the driver
- )
+from typing import Any, Dict, Optional
+
+from PyQt5.QtCore import QObject, QSettings, QThread, pyqtSignal
+from PyQt5.QtGui import QCloseEvent
+from PyQt5.QtWidgets import (
+ QApplication,
+ QCheckBox,
+ QComboBox,
+ QDoubleSpinBox,
+ QFileDialog,
+ QFormLayout,
+ QHBoxLayout,
+ QLabel,
+ QLineEdit,
+ QMainWindow,
+ QPushButton,
+ QSpinBox,
+ QVBoxLayout,
+ QWidget,
+)
- logger.info(
- f"Consumer buffer sized to {self.consumer_buffer_size:,} samples "
- f"({consumer_buffer_duration_s}s at effective rate)"
- )
- logger.info(
- f"Pico driver buffer sized to {self.pico_driver_buffer_size:,} samples "
- f"({driver_buffer_duration_s}s at effective rate)"
- )
+from picostream.cli import Streamer, VOLTAGE_RANGE_MAP
+from picostream.dfplot import HDF5LivePlotter
- # --- Plotting Decimation ---
- # Calculate the decimation factor needed to achieve the target number of plot points.
- points_per_timestep = 2 if downsample_mode == "aggregate" else 1
- samples_in_window = effective_rate_sps * plot_window_s * points_per_timestep
- self.decimation_factor = max(1, int(samples_in_window / plot_points))
- logger.info(
- f"Plotting with target of {plot_points} points. "
- f"Calculated decimation factor: {self.decimation_factor}"
- )
- # Picoscope hardware settings
- self.pico_resolution = f"PS5000A_DR_{resolution_bits}BIT"
- self.pico_channel_range = channel_range_str
- self.pico_sample_interval_ns = int(1000 / sample_rate_msps)
- self.pico_sample_unit = "PS5000A_NS"
-
- # Streaming settings
- self.pico_auto_stop = 0 # Don't auto stop
- self.pico_auto_stop_stream = False
- # --- End Configuration ---
-
- # --- System Components ---
- self.shutdown_event: threading.Event = threading.Event()
- data_queue: queue.Queue[int] = queue.Queue()
- empty_queue: queue.Queue[int] = queue.Queue()
- data_buffers: List[np.ndarray] = []
-
- # Pre-allocate a pool of numpy arrays for data transfer and populate the
- # empty_queue with their indices.
- for idx in range(self.consumer_num_buffers):
- data_buffers.append(np.empty((self.consumer_buffer_size,), dtype="int16"))
- empty_queue.put(idx)
-
- # --- Producer ---
- self.pico_device: PicoDevice = PicoDevice(
- 0, # handle
- self.pico_resolution,
- self.pico_driver_buffer_size,
- self.pico_driver_num_buffers,
- self.consumer_buffer_size,
- data_queue,
- empty_queue,
- data_buffers,
- self.shutdown_event,
- downsample_mode=downsample_mode,
- )
+class StreamerWorker(QObject):
+ """Worker to run the data acquisition in a background thread."""
- self.pico_device.set_channel(
- "PS5000A_CHANNEL_A", 1, "PS5000A_DC", self.pico_channel_range, offset_v
- )
- self.pico_device.set_channel(
- "PS5000A_CHANNEL_B", 0, "PS5000A_DC", self.pico_channel_range, 0.0
- )
- self.pico_device.set_data_buffer("PS5000A_CHANNEL_A", 0, pico_ratio_mode)
- self.pico_device.configure_streaming_var(
- self.pico_sample_interval_ns,
- self.pico_sample_unit,
- 0, # pre-trigger samples
- pico_downsample_ratio,
- pico_ratio_mode,
- self.pico_auto_stop,
- self.pico_auto_stop_stream,
+ finished = pyqtSignal()
+ error = pyqtSignal(str)
+
+ def __init__(self, settings: Dict[str, Any]) -> None:
+ """Initialise the worker."""
+ super().__init__()
+ self.streamer: Optional[Streamer] = None
+ self.settings = settings
+
+ def run(self) -> None:
+ """Run the data acquisition."""
+ try:
+ self.streamer = Streamer(**self.settings)
+ self.streamer.run()
+ except Exception as e:
+ self.error.emit(str(e))
+ return # Do not emit finished signal on error
+ self.finished.emit()
+
+ def stop(self) -> None:
+ """Signal the acquisition to stop."""
+ if self.streamer:
+ self.streamer.shutdown()
+
+
+class PicoStreamMainWindow(QMainWindow):
+ """The main window for the PicoStream GUI application."""
+
+ def __init__(self) -> None:
+ """Initialise the main window."""
+ super().__init__()
+ self.setWindowTitle("PicoStream")
+ self.setGeometry(100, 100, 1200, 600)
+
+ self.settings = QSettings("picostream", "PicoStream")
+ self.thread: Optional[QThread] = None
+ self.worker: Optional[StreamerWorker] = None
+
+ central_widget = QWidget()
+ self.setCentralWidget(central_widget)
+ main_layout = QHBoxLayout(central_widget)
+
+ # Left panel for settings
+ settings_panel = QWidget()
+ settings_panel.setFixedWidth(350)
+ settings_layout = QVBoxLayout(settings_panel)
+ form_layout = QFormLayout()
+
+ self.sample_rate_input = QDoubleSpinBox()
+ self.sample_rate_input.setRange(1, 125)
+ self.sample_rate_input.setValue(62.5)
+ self.sample_rate_input.setSuffix(" MS/s")
+ form_layout.addRow("Sample Rate:", self.sample_rate_input)
+
+ self.resolution_input = QComboBox()
+ self.resolution_input.addItems(["12", "14", "15", "16", "8"])
+ form_layout.addRow("Resolution (bits):", self.resolution_input)
+
+ self.voltage_range_input = QComboBox()
+ self.voltage_range_input.addItems(VOLTAGE_RANGE_MAP.values())
+ form_layout.addRow("Voltage Range:", self.voltage_range_input)
+
+ self.output_file_input = QLineEdit()
+ self.output_file_input.setText("output.hdf5")
+ file_browse_button = QPushButton("Browse...")
+ file_browse_button.clicked.connect(self.select_output_file)
+ file_layout = QHBoxLayout()
+ file_layout.addWidget(self.output_file_input)
+ file_layout.addWidget(file_browse_button)
+ form_layout.addRow("Output File:", file_layout)
+
+ self.hw_downsample_input = QSpinBox()
+ self.hw_downsample_input.setRange(1, 1000)
+ form_layout.addRow("HW Downsample:", self.hw_downsample_input)
+
+ self.downsample_mode_input = QComboBox()
+ self.downsample_mode_input.addItems(["average", "aggregate"])
+ form_layout.addRow("Downsample Mode:", self.downsample_mode_input)
+
+ self.offset_v_input = QDoubleSpinBox()
+ self.offset_v_input.setRange(-1.0, 1.0)
+ self.offset_v_input.setSingleStep(0.01)
+ self.offset_v_input.setDecimals(3)
+ self.offset_v_input.setSuffix(" V")
+ form_layout.addRow("Offset:", self.offset_v_input)
+
+ self.live_only_checkbox = QCheckBox("Live-only (overwrite buffer)")
+ self.max_buffer_input = QDoubleSpinBox()
+ self.max_buffer_input.setRange(0.1, 60.0)
+ self.max_buffer_input.setValue(1.0)
+ self.max_buffer_input.setSuffix(" s")
+ self.live_only_checkbox.stateChanged.connect(
+ lambda state: self.max_buffer_input.setEnabled(state > 0)
)
+ form_layout.addRow(self.live_only_checkbox, self.max_buffer_input)
+
+ settings_layout.addLayout(form_layout)
+
+ self.start_button = QPushButton("Start Acquisition")
+ self.stop_button = QPushButton("Stop Acquisition")
+ self.stop_button.setEnabled(False)
+
+ settings_layout.addWidget(self.start_button)
+ settings_layout.addWidget(self.stop_button)
+ settings_layout.addStretch()
+
+ # Right panel for the plot
+ self.plotter = HDF5LivePlotter(hdf5_path=self.output_file_input.text())
+
+ main_layout.addWidget(settings_panel)
+ main_layout.addWidget(self.plotter, 1)
+
+ # Connect signals
+ self.start_button.clicked.connect(self.start_acquisition)
+ self.stop_button.clicked.connect(self.stop_acquisition)
+ self.output_file_input.textChanged.connect(self.plotter.set_hdf5_path)
- # Run streaming once to get the actual sample interval from the driver
- self.pico_device.run_streaming()
-
- # --- Consumer ---
- # Prepare metadata for the consumer
- acquisition_start_time_utc = datetime.utcnow().isoformat() + "Z"
- was_live_mode = self.max_buffer_seconds is not None
-
- # Get metadata from configured device and pass to consumer
- metadata = self.pico_device.get_metadata(
- acquisition_start_time_utc=acquisition_start_time_utc,
- picostream_version=__version__,
- acquisition_command="", # Will be set later in main()
- was_live_mode=was_live_mode
+ self.load_settings()
+
+
+ def select_output_file(self) -> None:
+ """Open a dialog to select the output HDF5 file."""
+ file_name, _ = QFileDialog.getSaveFileName(
+ self, "Select Output File", self.output_file_input.text(), "HDF5 Files (*.hdf5)"
)
-
- # Calculate max samples for live-only mode
- max_samples = None
- if self.max_buffer_seconds:
- max_samples = int(effective_rate_sps * self.max_buffer_seconds)
- if downsample_mode == "aggregate":
- max_samples *= 2
- logger.info(f"Live-only mode: limiting buffer to {self.max_buffer_seconds}s ({max_samples:,} samples)")
-
- self.consumer: Consumer = Consumer(
- self.consumer_buffer_size,
- data_queue,
- empty_queue,
- data_buffers,
- output_file,
- self.shutdown_event,
- metadata=metadata,
- max_samples=max_samples,
+ if file_name:
+ self.output_file_input.setText(file_name)
+
+ def start_acquisition(self) -> None:
+ """Start the background data acquisition."""
+ self.start_button.setEnabled(False)
+ self.stop_button.setEnabled(True)
+
+ settings = {
+ "sample_rate_msps": self.sample_rate_input.value(),
+ "resolution_bits": int(self.resolution_input.currentText()),
+ "channel_range_str": self.voltage_range_input.currentText(),
+ "output_file": self.output_file_input.text(),
+ "hardware_downsample": self.hw_downsample_input.value(),
+ "downsample_mode": self.downsample_mode_input.currentText(),
+ "offset_v": self.offset_v_input.value(),
+ "max_buffer_seconds": self.max_buffer_input.value()
+ if self.live_only_checkbox.isChecked()
+ else None,
+ "enable_live_plot": False,
+ }
+
+ self.thread = QThread()
+ self.worker = StreamerWorker(settings)
+ self.worker.moveToThread(self.thread)
+
+ self.thread.started.connect(self.worker.run)
+ self.worker.finished.connect(self.thread.quit)
+ self.worker.finished.connect(self.worker.deleteLater)
+ self.thread.finished.connect(self.thread.deleteLater)
+ self.worker.finished.connect(self.on_acquisition_finished)
+ self.worker.error.connect(self.on_acquisition_error)
+
+ self.thread.start()
+
+ def stop_acquisition(self) -> None:
+ """Stop the background data acquisition."""
+ if self.worker:
+ self.worker.stop()
+ self.stop_button.setEnabled(False)
+
+ def on_acquisition_finished(self) -> None:
+ """Handle successful acquisition completion."""
+ print("Acquisition finished.")
+ self.start_button.setEnabled(True)
+ self.stop_button.setEnabled(False)
+ self.thread = None
+ self.worker = None
+
+ def on_acquisition_error(self, err_msg: str) -> None:
+ """Handle acquisition error."""
+ print(f"Acquisition error: {err_msg}")
+ # In a real app, show a QMessageBox
+ self.start_button.setEnabled(True)
+ self.stop_button.setEnabled(False)
+ self.thread = None
+ self.worker = None
+
+ def closeEvent(self, event: QCloseEvent) -> None:
+ """Handle window close event."""
+ self.save_settings()
+ if self.thread and self.thread.isRunning():
+ self.stop_acquisition()
+ self.thread.wait() # Wait for the thread to finish
+ event.accept()
+
+ def save_settings(self) -> None:
+ """Save current settings."""
+ self.settings.setValue("sample_rate", self.sample_rate_input.value())
+ self.settings.setValue("resolution", self.resolution_input.currentText())
+ self.settings.setValue("voltage_range", self.voltage_range_input.currentText())
+ self.settings.setValue("output_file", self.output_file_input.text())
+ self.settings.setValue("hw_downsample", self.hw_downsample_input.value())
+ self.settings.setValue("downsample_mode", self.downsample_mode_input.currentText())
+ self.settings.setValue("offset_v", self.offset_v_input.value())
+ self.settings.setValue("live_only_mode", self.live_only_checkbox.isChecked())
+ self.settings.setValue("max_buffer_seconds", self.max_buffer_input.value())
+
+ def load_settings(self) -> None:
+ """Load settings."""
+ self.sample_rate_input.setValue(self.settings.value("sample_rate", 62.5, type=float))
+ self.resolution_input.setCurrentText(self.settings.value("resolution", "12"))
+ self.voltage_range_input.setCurrentText(
+ self.settings.value("voltage_range", "PS5000A_20V")
)
-
- # --- Threads ---
- self.consumer_thread: threading.Thread = threading.Thread(
- target=self.consumer.consume
+ self.output_file_input.setText(self.settings.value("output_file", "output.hdf5"))
+ self.hw_downsample_input.setValue(self.settings.value("hw_downsample", 1, type=int))
+ self.downsample_mode_input.setCurrentText(
+ self.settings.value("downsample_mode", "average")
)
- self.pico_thread: threading.Thread = threading.Thread(
- target=self.pico_device.run_capture
+ self.offset_v_input.setValue(self.settings.value("offset_v", 0.0, type=float))
+ live_only = self.settings.value("live_only_mode", False, type=bool)
+ self.live_only_checkbox.setChecked(live_only)
+ self.max_buffer_input.setValue(
+ self.settings.value("max_buffer_seconds", 1.0, type=float)
)
+ self.max_buffer_input.setEnabled(live_only)
- # --- Signal Handling ---
- # Only set the signal handler if not in GUI mode.
- # In GUI mode, the main function will handle signals to quit the Qt app.
- if not self.enable_live_plot:
- signal.signal(signal.SIGINT, self.signal_handler)
-
- # --- Live Plotting (optional) ---
- self.start_time: Optional[float] = None
-
- def update_acquisition_command(self, command: str) -> None:
- """Update the acquisition command in the consumer's metadata."""
- self.consumer.metadata["acquisition_command"] = command
-
- def _validate_config(
- self,
- resolution_bits: int,
- sample_rate_msps: float,
- channel_range_str: str,
- hardware_downsample: int,
- downsample_mode: str,
- offset_v: float,
- ) -> tuple[float, int, str, float]:
- """Validates user-provided settings and returns derived configuration."""
- if resolution_bits == 8:
- max_rate_msps = 125.0
- elif resolution_bits in [12, 14, 15, 16]:
- max_rate_msps = 62.5
- else:
- raise ValueError(
- f"Unsupported resolution: {resolution_bits} bits. Must be one of 8, 12, 14, 15, 16."
- )
-
- if sample_rate_msps <= 0:
- sample_rate_msps = max_rate_msps
- logger.info(f"Max sample rate requested. Setting to {max_rate_msps} MS/s.")
-
- if sample_rate_msps > max_rate_msps:
- raise ValueError(
- f"Sample rate {sample_rate_msps} MS/s exceeds maximum of {max_rate_msps} MS/s for {resolution_bits}-bit resolution."
- )
-
- # Check if sample rate is excessive for the analog bandwidth.
- # Bandwidth is dependent on both resolution and voltage range.
- # (Based on PicoScope 5000A/B Series datasheet)
- inv_voltage_map = {v: k for k, v in VOLTAGE_RANGE_MAP.items()}
- voltage_v = inv_voltage_map.get(channel_range_str, 0)
-
- if resolution_bits == 16:
- bandwidth_mhz = 20 # 20 MHz for all ranges
- elif resolution_bits == 15:
- # Bandwidth is 70MHz for < ±5V, 60MHz for >= ±5V
- bandwidth_mhz = 70 if voltage_v < 5.0 else 60
- else: # 8-14 bits
- # Bandwidth is 100MHz for < ±5V, 60MHz for >= ±5V
- bandwidth_mhz = 100 if voltage_v < 5.0 else 60
-
- # Nyquist rate is 2x bandwidth. A common rule of thumb is 3-5x.
- # Warn if sampling faster than 5x the analog bandwidth.
- if sample_rate_msps > 5 * bandwidth_mhz:
- logger.warning(
- f"Sample rate ({sample_rate_msps} MS/s) may be unnecessarily high "
- f"for the selected voltage range ({channel_range_str}), which has an "
- f"analog bandwidth of {bandwidth_mhz} MHz."
- )
-
- if downsample_mode == "aggregate" and hardware_downsample <= 1:
- raise ValueError(
- "Hardware downsample ratio must be > 1 for 'aggregate' mode."
- )
-
- if hardware_downsample > 1:
- pico_downsample_ratio = hardware_downsample
- pico_ratio_mode = f"PS5000A_RATIO_MODE_{downsample_mode.upper()}"
- logger.info(
- f"Hardware down-sampling ({downsample_mode}) enabled "
- + f"with ratio {pico_downsample_ratio}."
- )
- else:
- pico_downsample_ratio = 1
- pico_ratio_mode = "PS5000A_RATIO_MODE_NONE"
-
- # Validate analog offset
- if offset_v != 0.0:
- if voltage_v >= 5.0:
- raise ValueError(
- f"Analog offset is not supported for voltage ranges >= 5V (selected: {channel_range_str})."
- )
- if abs(offset_v) > voltage_v:
- raise ValueError(
- f"Analog offset ({offset_v}V) exceeds the selected voltage range (±{voltage_v}V)."
- )
- logger.info(f"Analog offset set to {offset_v:.3f}V.")
-
- return sample_rate_msps, pico_downsample_ratio, pico_ratio_mode, offset_v
-
- def signal_handler(self, _sig: int, frame: Optional[object]) -> None:
- """Handles Ctrl+C interrupts to initiate a graceful shutdown."""
- logger.warning("Ctrl+C detected. Shutting down.")
- self.shutdown()
-
- def shutdown(self) -> None:
- """Performs a graceful shutdown of all components.
-
- This method calculates final statistics, stops all threads, closes the
- plotter, and ensures the Picoscope device is properly closed.
- """
- if self.shutdown_event.is_set():
- return
-
- self._log_acquisition_summary()
- self.shutdown_event.set()
-
- logger.info("Stopping data acquisition and saving...")
-
- self._join_threads()
- self.pico_device.close_device()
-
- logger.success("Shutdown complete.")
-
- def _log_acquisition_summary(self) -> None:
- """Calculates and logs final acquisition statistics."""
- if not self.start_time:
- return
-
- end_time = time.time()
- duration = end_time - self.start_time
- total_samples = self.consumer.values_written
- effective_rate_msps = (total_samples / duration) / 1e6 if duration > 0 else 0
- configured_rate_msps = 1e3 / self.pico_device.sample_int.value
-
- logger.info("--- Acquisition Summary ---")
- logger.info(f"Total acquisition time: {duration:.2f} s")
- logger.info(
- "Total samples written: "
- + f"{self.consumer.format_sample_count(total_samples)}"
- )
- logger.info(f"Configured sample rate: {configured_rate_msps:.2f} MS/s")
- logger.info(f"Effective average rate: {effective_rate_msps:.2f} MS/s")
- rate_ratio = (
- effective_rate_msps / configured_rate_msps
- if configured_rate_msps > 0
- else 0
- )
- if rate_ratio < 0.95:
- logger.warning(
- f"Effective rate was only {rate_ratio:.1%} " + "of the configured rate."
- )
- else:
- logger.success("Effective rate matches configured rate.")
- logger.info("--------------------------")
-
- def _join_threads(self) -> None:
- """Waits for the producer and consumer threads to terminate."""
- for thread_name in ["pico_thread", "consumer_thread"]:
- thread = getattr(self, thread_name, None)
- if thread and thread.is_alive():
- logger.info(f"Waiting for {thread_name} to terminate...")
- thread.join(timeout=2.0)
- if thread.is_alive():
- logger.critical(f"{thread_name} failed to terminate.")
-
- def run(self, app: Optional[QApplication] = None) -> None:
- """Starts the acquisition threads and optionally the Qt event loop."""
- # Start acquisition threads
- self.start_time = time.time()
- self.consumer_thread.start()
- self.pico_thread.start()
-
- # Handle Qt event loop if plotting is enabled
- if self.enable_live_plot and app:
- from .dfplot import HDF5LivePlotter
-
- plotter = HDF5LivePlotter(
- hdf5_path=self.output_file,
- display_window_seconds=self.plot_window_s,
- decimation_factor=self.decimation_factor,
- shutdown_event=self.shutdown_event,
- )
- plotter.show()
-
- # Run the Qt event loop. This will block until the plot window is closed.
- app.exec_()
-
- # Once the window is closed, the shutdown event should have been set.
- # We call shutdown() to ensure threads are joined and cleanup happens.
- self.shutdown()
- else:
- # Original non-GUI behavior
- self.consumer_thread.join()
- self.pico_thread.join()
- logger.success("Acquisition complete!")
-
-
-# --- Argument Parsing ---
-VOLTAGE_RANGE_MAP = {
- 0.01: "PS5000A_10MV",
- 0.02: "PS5000A_20MV",
- 0.05: "PS5000A_50MV",
- 0.1: "PS5000A_100MV",
- 0.2: "PS5000A_200MV",
- 0.5: "PS5000A_500MV",
- 1: "PS5000A_1V",
- 2: "PS5000A_2V",
- 5: "PS5000A_5V",
- 10: "PS5000A_10V",
- 20: "PS5000A_20V",
-}
-
-
-def generate_unique_filename(base_path: str) -> str:
- """Generate a unique filename by appending timestamp if file exists."""
- import os
- from pathlib import Path
-
- if not os.path.exists(base_path):
- return base_path
-
- # Split the path into parts
- path = Path(base_path)
- stem = path.stem
- suffix = path.suffix
- parent = path.parent
-
- # Generate timestamp
- timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-
- # Create new filename with timestamp
- new_filename = f"{stem}_{timestamp}{suffix}"
- new_path = parent / new_filename
-
- return str(new_path)
-
-
-@click.command()
-@click.option(
- "--sample-rate",
- "-s",
- type=float,
- default=20,
- help="Sample rate in MS/s (e.g., 62.5). Use 0 for max rate. [default: 20]",
-)
-@click.option(
- "--resolution",
- "-b",
- type=click.Choice(["8", "12", "16"]),
- default="12",
- help="Resolution in bits. [default: 12]",
-)
-@click.option(
- "--rangev",
- "-r",
- type=click.Choice([str(k) for k in sorted(VOLTAGE_RANGE_MAP.keys())]),
- default="20",
- help=f"Voltage range in Volts. [default: 20]",
-)
-@click.option(
- "--plot/--no-plot",
- "-p",
- is_flag=True,
- default=True,
- help="Enable/disable live plotting. [default: --plot]",
-)
-@click.option(
- "--output",
- "-o",
- type=click.Path(dir_okay=False, writable=True),
- help="Output HDF5 file (default: auto-timestamped).",
-)
-@click.option(
- "--plot-window",
- "-w",
- type=float,
- default=0.5,
- help="Live plot display window duration in seconds. [default: 0.5]",
-)
-@click.option(
- "--verbose", "-v", is_flag=True, default=False, help="Enable debug logging."
-)
-@click.option(
- "--plot-npts",
- "-n",
- type=int,
- default=4000,
- help="Target number of points for the plot window. [default: 4000]",
-)
-@click.option(
- "--hardware-downsample",
- "-h",
- type=int,
- default=1,
- help="Hardware down-sampling ratio (power of 2 for 'average' mode). [default: 1]",
-)
-@click.option(
- "--downsample-mode",
- "-m",
- type=click.Choice(["average", "aggregate"]),
- default="average",
- help="Hardware down-sampling mode. [default: average]",
-)
-@click.option(
- "--offset",
- type=float,
- default=0.0,
- help="Analog offset in Volts (only for ranges < 5V). [default: 0.0]",
-)
-@click.option(
- "--max-buff-sec",
- type=float,
- help="Maximum buffer duration in seconds for live-only mode (limits file size).",
-)
-@click.option(
- "--force",
- "-f",
- is_flag=True,
- default=False,
- help="Overwrite existing output file.",
-)
-def main(
- sample_rate: float,
- resolution: str,
- rangev: str,
- plot: bool,
- output: Optional[str],
- plot_window: float,
- verbose: bool,
- plot_npts: int,
- hardware_downsample: int,
- downsample_mode: str,
- offset: float,
- max_buff_sec: Optional[float],
- force: bool,
-) -> None:
- """High-speed data acquisition tool for Picoscope 5000a series."""
- # --- Argument Validation and Processing ---
- channel_range_str = VOLTAGE_RANGE_MAP[float(rangev)]
- resolution_bits = int(resolution)
-
- app: Optional[QApplication] = None
- if plot:
- from PyQt5.QtWidgets import QApplication
-
- app = QApplication(sys.argv)
-
- # When plotting, SIGINT should gracefully close the Qt application.
- # The main loop will then handle the shutdown.
- def sigint_handler(_sig: int, _frame: Optional[object]) -> None:
- logger.warning("Ctrl+C detected. Closing application.")
- QApplication.quit()
-
- signal.signal(signal.SIGINT, sigint_handler)
-
- # Configure logging
- logger.remove()
- log_level = "DEBUG" if verbose else "INFO"
- logger.add(sys.stderr, level=log_level)
- logger.info(f"Logging configured at level: {log_level}")
-
- # Auto-generate filename if not specified
- if not output:
- timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
- output = f"./output_{timestamp}.hdf5"
- else:
- # Check if file exists and handle accordingly
- if not force:
- original_output = output
- output = generate_unique_filename(output)
- if output != original_output:
- logger.info(f"File '{original_output}' exists. Using '{output}' instead.")
- logger.info("Use --force/-f to overwrite existing files.")
-
- logger.info(f"Output file: {output}")
- logger.info(f"Selected voltage range: {rangev}V -> {channel_range_str}")
-
- try:
- # Create and run the streamer
- streamer = Streamer(
- sample_rate_msps=sample_rate,
- resolution_bits=resolution_bits,
- channel_range_str=channel_range_str,
- enable_live_plot=plot,
- output_file=output,
- debug=verbose,
- plot_window_s=plot_window,
- plot_points=plot_npts,
- hardware_downsample=hardware_downsample,
- downsample_mode=downsample_mode,
- offset_v=offset,
- max_buffer_seconds=max_buff_sec,
- )
-
- # Update the acquisition command in metadata
- acquisition_command = " ".join(sys.argv)
- streamer.update_acquisition_command(acquisition_command)
-
- streamer.run(app)
- except RuntimeError as e:
- if "PICO_NOT_FOUND" in str(e):
- logger.critical(
- "Picoscope device not found. Please check connection and ensure no other software is using it."
- )
- else:
- logger.critical(f"Failed to initialize Picoscope: {e}")
- sys.exit(1)
-
- # --- Verification Step ---
- # Skip verification in live-only mode since file size is limited
- if not streamer.max_buffer_seconds:
- logger.info(f"Verifying output file: {output}")
- try:
- expected_samples = streamer.consumer.values_written
- if expected_samples == 0:
- logger.warning("Consumer processed no samples. Nothing to verify.")
- else:
- with h5py.File(output, "r") as f:
- if "adc_counts" not in f:
- raise ValueError("Dataset 'adc_counts' not found in HDF5 file.")
-
- actual_samples = len(f["adc_counts"])
- if actual_samples == expected_samples:
- logger.success(
- f"Verification PASSED: File contains {actual_samples} samples, as expected."
- )
- else:
- logger.error(
- f"Verification FAILED: Expected {expected_samples} samples, but file has {actual_samples}."
- )
- except Exception as e:
- logger.error(f"HDF5 file verification failed: {e}")
- else:
- logger.info("Skipping verification in live-only mode.")
+def main() -> None:
+ """GUI entry point."""
+ app = QApplication(sys.argv)
+ main_win = PicoStreamMainWindow()
+ main_win.show()
+ sys.exit(app.exec_())
if __name__ == "__main__":
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..8481d90
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,268 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "click"
+version = "8.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/46/61/de6cd827efad202d7057d93e0fed9294b96952e188f7384832791c7b2254/click-8.3.0.tar.gz", hash = "sha256:e7b8232224eba16f4ebe410c25ced9f7875cb5f3263ffc93cc3e8da705e229c4", size = 276943, upload-time = "2025-09-18T17:32:23.696Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/db/d3/9dcc0f5797f070ec8edf30fbadfb200e71d9db6b84d211e3b2085a7589a0/click-8.3.0-py3-none-any.whl", hash = "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc", size = 107295, upload-time = "2025-09-18T17:32:22.42Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "h5py"
+version = "3.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5d/57/dfb3c5c3f1bf5f5ef2e59a22dec4ff1f3d7408b55bfcefcfb0ea69ef21c6/h5py-3.14.0.tar.gz", hash = "sha256:2372116b2e0d5d3e5e705b7f663f7c8d96fa79a4052d250484ef91d24d6a08f4", size = 424323, upload-time = "2025-06-06T14:06:15.01Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/3e/77/8f651053c1843391e38a189ccf50df7e261ef8cd8bfd8baba0cbe694f7c3/h5py-3.14.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e0045115d83272090b0717c555a31398c2c089b87d212ceba800d3dc5d952e23", size = 3312740, upload-time = "2025-06-06T14:05:01.193Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/10/20436a6cf419b31124e59fefc78d74cb061ccb22213226a583928a65d715/h5py-3.14.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6da62509b7e1d71a7d110478aa25d245dd32c8d9a1daee9d2a42dba8717b047a", size = 2829207, upload-time = "2025-06-06T14:05:05.061Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/19/c8bfe8543bfdd7ccfafd46d8cfd96fce53d6c33e9c7921f375530ee1d39a/h5py-3.14.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:554ef0ced3571366d4d383427c00c966c360e178b5fb5ee5bb31a435c424db0c", size = 4708455, upload-time = "2025-06-06T14:05:11.528Z" },
+ { url = "https://files.pythonhosted.org/packages/86/f9/f00de11c82c88bfc1ef22633557bfba9e271e0cb3189ad704183fc4a2644/h5py-3.14.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0cbd41f4e3761f150aa5b662df991868ca533872c95467216f2bec5fcad84882", size = 4929422, upload-time = "2025-06-06T14:05:18.399Z" },
+ { url = "https://files.pythonhosted.org/packages/7a/6d/6426d5d456f593c94b96fa942a9b3988ce4d65ebaf57d7273e452a7222e8/h5py-3.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:bf4897d67e613ecf5bdfbdab39a1158a64df105827da70ea1d90243d796d367f", size = 2862845, upload-time = "2025-06-06T14:05:23.699Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/c2/7efe82d09ca10afd77cd7c286e42342d520c049a8c43650194928bcc635c/h5py-3.14.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:aa4b7bbce683379b7bf80aaba68e17e23396100336a8d500206520052be2f812", size = 3289245, upload-time = "2025-06-06T14:05:28.24Z" },
+ { url = "https://files.pythonhosted.org/packages/4f/31/f570fab1239b0d9441024b92b6ad03bb414ffa69101a985e4c83d37608bd/h5py-3.14.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ef9603a501a04fcd0ba28dd8f0995303d26a77a980a1f9474b3417543d4c6174", size = 2807335, upload-time = "2025-06-06T14:05:31.997Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/ce/3a21d87896bc7e3e9255e0ad5583ae31ae9e6b4b00e0bcb2a67e2b6acdbc/h5py-3.14.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8cbaf6910fa3983c46172666b0b8da7b7bd90d764399ca983236f2400436eeb", size = 4700675, upload-time = "2025-06-06T14:05:37.38Z" },
+ { url = "https://files.pythonhosted.org/packages/e7/ec/86f59025306dcc6deee5fda54d980d077075b8d9889aac80f158bd585f1b/h5py-3.14.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d90e6445ab7c146d7f7981b11895d70bc1dd91278a4f9f9028bc0c95e4a53f13", size = 4921632, upload-time = "2025-06-06T14:05:43.464Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/6d/0084ed0b78d4fd3e7530c32491f2884140d9b06365dac8a08de726421d4a/h5py-3.14.0-cp313-cp313-win_amd64.whl", hash = "sha256:ae18e3de237a7a830adb76aaa68ad438d85fe6e19e0d99944a3ce46b772c69b3", size = 2852929, upload-time = "2025-06-06T14:05:47.659Z" },
+]
+
+[[package]]
+name = "llvmlite"
+version = "0.45.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/99/8d/5baf1cef7f9c084fb35a8afbde88074f0d6a727bc63ef764fe0e7543ba40/llvmlite-0.45.1.tar.gz", hash = "sha256:09430bb9d0bb58fc45a45a57c7eae912850bedc095cd0810a57de109c69e1c32", size = 185600, upload-time = "2025-10-01T17:59:52.046Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e2/7c/82cbd5c656e8991bcc110c69d05913be2229302a92acb96109e166ae31fb/llvmlite-0.45.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:28e763aba92fe9c72296911e040231d486447c01d4f90027c8e893d89d49b20e", size = 43043524, upload-time = "2025-10-01T18:03:30.666Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/bc/5314005bb2c7ee9f33102c6456c18cc81745d7055155d1218f1624463774/llvmlite-0.45.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1a53f4b74ee9fd30cb3d27d904dadece67a7575198bd80e687ee76474620735f", size = 37253123, upload-time = "2025-10-01T18:04:18.177Z" },
+ { url = "https://files.pythonhosted.org/packages/96/76/0f7154952f037cb320b83e1c952ec4a19d5d689cf7d27cb8a26887d7bbc1/llvmlite-0.45.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b3796b1b1e1c14dcae34285d2f4ea488402fbd2c400ccf7137603ca3800864f", size = 56288211, upload-time = "2025-10-01T18:01:24.079Z" },
+ { url = "https://files.pythonhosted.org/packages/00/b1/0b581942be2683ceb6862d558979e87387e14ad65a1e4db0e7dd671fa315/llvmlite-0.45.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:779e2f2ceefef0f4368548685f0b4adde34e5f4b457e90391f570a10b348d433", size = 55140958, upload-time = "2025-10-01T18:02:30.482Z" },
+ { url = "https://files.pythonhosted.org/packages/33/94/9ba4ebcf4d541a325fd8098ddc073b663af75cc8b065b6059848f7d4dce7/llvmlite-0.45.1-cp312-cp312-win_amd64.whl", hash = "sha256:9e6c9949baf25d9aa9cd7cf0f6d011b9ca660dd17f5ba2b23bdbdb77cc86b116", size = 38132231, upload-time = "2025-10-01T18:05:03.664Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/e2/c185bb7e88514d5025f93c6c4092f6120c6cea8fe938974ec9860fb03bbb/llvmlite-0.45.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:d9ea9e6f17569a4253515cc01dade70aba536476e3d750b2e18d81d7e670eb15", size = 43043524, upload-time = "2025-10-01T18:03:43.249Z" },
+ { url = "https://files.pythonhosted.org/packages/09/b8/b5437b9ecb2064e89ccf67dccae0d02cd38911705112dd0dcbfa9cd9a9de/llvmlite-0.45.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:c9f3cadee1630ce4ac18ea38adebf2a4f57a89bd2740ce83746876797f6e0bfb", size = 37253121, upload-time = "2025-10-01T18:04:30.557Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/97/ad1a907c0173a90dd4df7228f24a3ec61058bc1a9ff8a0caec20a0cc622e/llvmlite-0.45.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:57c48bf2e1083eedbc9406fb83c4e6483017879714916fe8be8a72a9672c995a", size = 56288210, upload-time = "2025-10-01T18:01:40.26Z" },
+ { url = "https://files.pythonhosted.org/packages/32/d8/c99c8ac7a326e9735401ead3116f7685a7ec652691aeb2615aa732b1fc4a/llvmlite-0.45.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3aa3dfceda4219ae39cf18806c60eeb518c1680ff834b8b311bd784160b9ce40", size = 55140957, upload-time = "2025-10-01T18:02:46.244Z" },
+ { url = "https://files.pythonhosted.org/packages/09/56/ed35668130e32dbfad2eb37356793b0a95f23494ab5be7d9bf5cb75850ee/llvmlite-0.45.1-cp313-cp313-win_amd64.whl", hash = "sha256:080e6f8d0778a8239cd47686d402cb66eb165e421efa9391366a9b7e5810a38b", size = 38132232, upload-time = "2025-10-01T18:05:14.477Z" },
+]
+
+[[package]]
+name = "loguru"
+version = "0.7.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "sys_platform == 'win32'" },
+ { name = "win32-setctime", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", hash = "sha256:19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6", size = 63559, upload-time = "2024-12-06T11:20:56.608Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" },
+]
+
+[[package]]
+name = "numba"
+version = "0.62.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "llvmlite" },
+ { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a3/20/33dbdbfe60e5fd8e3dbfde299d106279a33d9f8308346022316781368591/numba-0.62.1.tar.gz", hash = "sha256:7b774242aa890e34c21200a1fc62e5b5757d5286267e71103257f4e2af0d5161", size = 2749817, upload-time = "2025-09-29T10:46:31.551Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/5e/fa/30fa6873e9f821c0ae755915a3ca444e6ff8d6a7b6860b669a3d33377ac7/numba-0.62.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:1b743b32f8fa5fff22e19c2e906db2f0a340782caf024477b97801b918cf0494", size = 2685346, upload-time = "2025-09-29T10:43:43.677Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/d5/504ce8dc46e0dba2790c77e6b878ee65b60fe3e7d6d0006483ef6fde5a97/numba-0.62.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:90fa21b0142bcf08ad8e32a97d25d0b84b1e921bc9423f8dda07d3652860eef6", size = 2688139, upload-time = "2025-09-29T10:44:04.894Z" },
+ { url = "https://files.pythonhosted.org/packages/50/5f/6a802741176c93f2ebe97ad90751894c7b0c922b52ba99a4395e79492205/numba-0.62.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6ef84d0ac19f1bf80431347b6f4ce3c39b7ec13f48f233a48c01e2ec06ecbc59", size = 3796453, upload-time = "2025-09-29T10:42:52.771Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/df/efd21527d25150c4544eccc9d0b7260a5dec4b7e98b5a581990e05a133c0/numba-0.62.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9315cc5e441300e0ca07c828a627d92a6802bcbf27c5487f31ae73783c58da53", size = 3496451, upload-time = "2025-09-29T10:43:19.279Z" },
+ { url = "https://files.pythonhosted.org/packages/80/44/79bfdab12a02796bf4f1841630355c82b5a69933b1d50eb15c7fa37dabe8/numba-0.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:44e3aa6228039992f058f5ebfcfd372c83798e9464297bdad8cc79febcf7891e", size = 2745552, upload-time = "2025-09-29T10:44:26.399Z" },
+ { url = "https://files.pythonhosted.org/packages/22/76/501ea2c07c089ef1386868f33dff2978f43f51b854e34397b20fc55e0a58/numba-0.62.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:b72489ba8411cc9fdcaa2458d8f7677751e94f0109eeb53e5becfdc818c64afb", size = 2685766, upload-time = "2025-09-29T10:43:49.161Z" },
+ { url = "https://files.pythonhosted.org/packages/80/68/444986ed95350c0611d5c7b46828411c222ce41a0c76707c36425d27ce29/numba-0.62.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:44a1412095534a26fb5da2717bc755b57da5f3053965128fe3dc286652cc6a92", size = 2688741, upload-time = "2025-09-29T10:44:10.07Z" },
+ { url = "https://files.pythonhosted.org/packages/78/7e/bf2e3634993d57f95305c7cee4c9c6cb3c9c78404ee7b49569a0dfecfe33/numba-0.62.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8c9460b9e936c5bd2f0570e20a0a5909ee6e8b694fd958b210e3bde3a6dba2d7", size = 3804576, upload-time = "2025-09-29T10:42:59.53Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/b6/8a1723fff71f63bbb1354bdc60a1513a068acc0f5322f58da6f022d20247/numba-0.62.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:728f91a874192df22d74e3fd42c12900b7ce7190b1aad3574c6c61b08313e4c5", size = 3503367, upload-time = "2025-09-29T10:43:26.326Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/ec/9d414e7a80d6d1dc4af0e07c6bfe293ce0b04ea4d0ed6c45dad9bd6e72eb/numba-0.62.1-cp313-cp313-win_amd64.whl", hash = "sha256:bbf3f88b461514287df66bc8d0307e949b09f2b6f67da92265094e8fa1282dd8", size = 2745529, upload-time = "2025-09-29T10:44:31.738Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.3.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/19/95b3d357407220ed24c139018d2518fab0a61a948e68286a25f1a4d049ff/numpy-2.3.3.tar.gz", hash = "sha256:ddc7c39727ba62b80dfdbedf400d1c10ddfa8eefbd7ec8dcb118be8b56d31029", size = 20576648, upload-time = "2025-09-09T16:54:12.543Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/51/5d/bb7fc075b762c96329147799e1bcc9176ab07ca6375ea976c475482ad5b3/numpy-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cfdd09f9c84a1a934cde1eec2267f0a43a7cd44b2cca4ff95b7c0d14d144b0bf", size = 20957014, upload-time = "2025-09-09T15:56:29.966Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/0e/c6211bb92af26517acd52125a237a92afe9c3124c6a68d3b9f81b62a0568/numpy-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cb32e3cf0f762aee47ad1ddc6672988f7f27045b0783c887190545baba73aa25", size = 14185220, upload-time = "2025-09-09T15:56:32.175Z" },
+ { url = "https://files.pythonhosted.org/packages/22/f2/07bb754eb2ede9073f4054f7c0286b0d9d2e23982e090a80d478b26d35ca/numpy-2.3.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:396b254daeb0a57b1fe0ecb5e3cff6fa79a380fa97c8f7781a6d08cd429418fe", size = 5113918, upload-time = "2025-09-09T15:56:34.175Z" },
+ { url = "https://files.pythonhosted.org/packages/81/0a/afa51697e9fb74642f231ea36aca80fa17c8fb89f7a82abd5174023c3960/numpy-2.3.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:067e3d7159a5d8f8a0b46ee11148fc35ca9b21f61e3c49fbd0a027450e65a33b", size = 6647922, upload-time = "2025-09-09T15:56:36.149Z" },
+ { url = "https://files.pythonhosted.org/packages/5d/f5/122d9cdb3f51c520d150fef6e87df9279e33d19a9611a87c0d2cf78a89f4/numpy-2.3.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c02d0629d25d426585fb2e45a66154081b9fa677bc92a881ff1d216bc9919a8", size = 14281991, upload-time = "2025-09-09T15:56:40.548Z" },
+ { url = "https://files.pythonhosted.org/packages/51/64/7de3c91e821a2debf77c92962ea3fe6ac2bc45d0778c1cbe15d4fce2fd94/numpy-2.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9192da52b9745f7f0766531dcfa978b7763916f158bb63bdb8a1eca0068ab20", size = 16641643, upload-time = "2025-09-09T15:56:43.343Z" },
+ { url = "https://files.pythonhosted.org/packages/30/e4/961a5fa681502cd0d68907818b69f67542695b74e3ceaa513918103b7e80/numpy-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cd7de500a5b66319db419dc3c345244404a164beae0d0937283b907d8152e6ea", size = 16056787, upload-time = "2025-09-09T15:56:46.141Z" },
+ { url = "https://files.pythonhosted.org/packages/99/26/92c912b966e47fbbdf2ad556cb17e3a3088e2e1292b9833be1dfa5361a1a/numpy-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:93d4962d8f82af58f0b2eb85daaf1b3ca23fe0a85d0be8f1f2b7bb46034e56d7", size = 18579598, upload-time = "2025-09-09T15:56:49.844Z" },
+ { url = "https://files.pythonhosted.org/packages/17/b6/fc8f82cb3520768718834f310c37d96380d9dc61bfdaf05fe5c0b7653e01/numpy-2.3.3-cp312-cp312-win32.whl", hash = "sha256:5534ed6b92f9b7dca6c0a19d6df12d41c68b991cef051d108f6dbff3babc4ebf", size = 6320800, upload-time = "2025-09-09T15:56:52.499Z" },
+ { url = "https://files.pythonhosted.org/packages/32/ee/de999f2625b80d043d6d2d628c07d0d5555a677a3cf78fdf868d409b8766/numpy-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:497d7cad08e7092dba36e3d296fe4c97708c93daf26643a1ae4b03f6294d30eb", size = 12786615, upload-time = "2025-09-09T15:56:54.422Z" },
+ { url = "https://files.pythonhosted.org/packages/49/6e/b479032f8a43559c383acb20816644f5f91c88f633d9271ee84f3b3a996c/numpy-2.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:ca0309a18d4dfea6fc6262a66d06c26cfe4640c3926ceec90e57791a82b6eee5", size = 10195936, upload-time = "2025-09-09T15:56:56.541Z" },
+ { url = "https://files.pythonhosted.org/packages/7d/b9/984c2b1ee61a8b803bf63582b4ac4242cf76e2dbd663efeafcb620cc0ccb/numpy-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f5415fb78995644253370985342cd03572ef8620b934da27d77377a2285955bf", size = 20949588, upload-time = "2025-09-09T15:56:59.087Z" },
+ { url = "https://files.pythonhosted.org/packages/a6/e4/07970e3bed0b1384d22af1e9912527ecbeb47d3b26e9b6a3bced068b3bea/numpy-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d00de139a3324e26ed5b95870ce63be7ec7352171bc69a4cf1f157a48e3eb6b7", size = 14177802, upload-time = "2025-09-09T15:57:01.73Z" },
+ { url = "https://files.pythonhosted.org/packages/35/c7/477a83887f9de61f1203bad89cf208b7c19cc9fef0cebef65d5a1a0619f2/numpy-2.3.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:9dc13c6a5829610cc07422bc74d3ac083bd8323f14e2827d992f9e52e22cd6a6", size = 5106537, upload-time = "2025-09-09T15:57:03.765Z" },
+ { url = "https://files.pythonhosted.org/packages/52/47/93b953bd5866a6f6986344d045a207d3f1cfbad99db29f534ea9cee5108c/numpy-2.3.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:d79715d95f1894771eb4e60fb23f065663b2298f7d22945d66877aadf33d00c7", size = 6640743, upload-time = "2025-09-09T15:57:07.921Z" },
+ { url = "https://files.pythonhosted.org/packages/23/83/377f84aaeb800b64c0ef4de58b08769e782edcefa4fea712910b6f0afd3c/numpy-2.3.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:952cfd0748514ea7c3afc729a0fc639e61655ce4c55ab9acfab14bda4f402b4c", size = 14278881, upload-time = "2025-09-09T15:57:11.349Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/a5/bf3db6e66c4b160d6ea10b534c381a1955dfab34cb1017ea93aa33c70ed3/numpy-2.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5b83648633d46f77039c29078751f80da65aa64d5622a3cd62aaef9d835b6c93", size = 16636301, upload-time = "2025-09-09T15:57:14.245Z" },
+ { url = "https://files.pythonhosted.org/packages/a2/59/1287924242eb4fa3f9b3a2c30400f2e17eb2707020d1c5e3086fe7330717/numpy-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b001bae8cea1c7dfdb2ae2b017ed0a6f2102d7a70059df1e338e307a4c78a8ae", size = 16053645, upload-time = "2025-09-09T15:57:16.534Z" },
+ { url = "https://files.pythonhosted.org/packages/e6/93/b3d47ed882027c35e94ac2320c37e452a549f582a5e801f2d34b56973c97/numpy-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8e9aced64054739037d42fb84c54dd38b81ee238816c948c8f3ed134665dcd86", size = 18578179, upload-time = "2025-09-09T15:57:18.883Z" },
+ { url = "https://files.pythonhosted.org/packages/20/d9/487a2bccbf7cc9d4bfc5f0f197761a5ef27ba870f1e3bbb9afc4bbe3fcc2/numpy-2.3.3-cp313-cp313-win32.whl", hash = "sha256:9591e1221db3f37751e6442850429b3aabf7026d3b05542d102944ca7f00c8a8", size = 6312250, upload-time = "2025-09-09T15:57:21.296Z" },
+ { url = "https://files.pythonhosted.org/packages/1b/b5/263ebbbbcede85028f30047eab3d58028d7ebe389d6493fc95ae66c636ab/numpy-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f0dadeb302887f07431910f67a14d57209ed91130be0adea2f9793f1a4f817cf", size = 12783269, upload-time = "2025-09-09T15:57:23.034Z" },
+ { url = "https://files.pythonhosted.org/packages/fa/75/67b8ca554bbeaaeb3fac2e8bce46967a5a06544c9108ec0cf5cece559b6c/numpy-2.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:3c7cf302ac6e0b76a64c4aecf1a09e51abd9b01fc7feee80f6c43e3ab1b1dbc5", size = 10195314, upload-time = "2025-09-09T15:57:25.045Z" },
+ { url = "https://files.pythonhosted.org/packages/11/d0/0d1ddec56b162042ddfafeeb293bac672de9b0cfd688383590090963720a/numpy-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:eda59e44957d272846bb407aad19f89dc6f58fecf3504bd144f4c5cf81a7eacc", size = 21048025, upload-time = "2025-09-09T15:57:27.257Z" },
+ { url = "https://files.pythonhosted.org/packages/36/9e/1996ca6b6d00415b6acbdd3c42f7f03ea256e2c3f158f80bd7436a8a19f3/numpy-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:823d04112bc85ef5c4fda73ba24e6096c8f869931405a80aa8b0e604510a26bc", size = 14301053, upload-time = "2025-09-09T15:57:30.077Z" },
+ { url = "https://files.pythonhosted.org/packages/05/24/43da09aa764c68694b76e84b3d3f0c44cb7c18cdc1ba80e48b0ac1d2cd39/numpy-2.3.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:40051003e03db4041aa325da2a0971ba41cf65714e65d296397cc0e32de6018b", size = 5229444, upload-time = "2025-09-09T15:57:32.733Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/14/50ffb0f22f7218ef8af28dd089f79f68289a7a05a208db9a2c5dcbe123c1/numpy-2.3.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:6ee9086235dd6ab7ae75aba5662f582a81ced49f0f1c6de4260a78d8f2d91a19", size = 6738039, upload-time = "2025-09-09T15:57:34.328Z" },
+ { url = "https://files.pythonhosted.org/packages/55/52/af46ac0795e09657d45a7f4db961917314377edecf66db0e39fa7ab5c3d3/numpy-2.3.3-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94fcaa68757c3e2e668ddadeaa86ab05499a70725811e582b6a9858dd472fb30", size = 14352314, upload-time = "2025-09-09T15:57:36.255Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/b1/dc226b4c90eb9f07a3fff95c2f0db3268e2e54e5cce97c4ac91518aee71b/numpy-2.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da1a74b90e7483d6ce5244053399a614b1d6b7bc30a60d2f570e5071f8959d3e", size = 16701722, upload-time = "2025-09-09T15:57:38.622Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/9d/9d8d358f2eb5eced14dba99f110d83b5cd9a4460895230f3b396ad19a323/numpy-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2990adf06d1ecee3b3dcbb4977dfab6e9f09807598d647f04d385d29e7a3c3d3", size = 16132755, upload-time = "2025-09-09T15:57:41.16Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/27/b3922660c45513f9377b3fb42240bec63f203c71416093476ec9aa0719dc/numpy-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ed635ff692483b8e3f0fcaa8e7eb8a75ee71aa6d975388224f70821421800cea", size = 18651560, upload-time = "2025-09-09T15:57:43.459Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/8e/3ab61a730bdbbc201bb245a71102aa609f0008b9ed15255500a99cd7f780/numpy-2.3.3-cp313-cp313t-win32.whl", hash = "sha256:a333b4ed33d8dc2b373cc955ca57babc00cd6f9009991d9edc5ddbc1bac36bcd", size = 6442776, upload-time = "2025-09-09T15:57:45.793Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/3a/e22b766b11f6030dc2decdeff5c2fb1610768055603f9f3be88b6d192fb2/numpy-2.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:4384a169c4d8f97195980815d6fcad04933a7e1ab3b530921c3fef7a1c63426d", size = 12927281, upload-time = "2025-09-09T15:57:47.492Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/42/c2e2bc48c5e9b2a83423f99733950fbefd86f165b468a3d85d52b30bf782/numpy-2.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:75370986cc0bc66f4ce5110ad35aae6d182cc4ce6433c40ad151f53690130bf1", size = 10265275, upload-time = "2025-09-09T15:57:49.647Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/01/342ad585ad82419b99bcf7cebe99e61da6bedb89e213c5fd71acc467faee/numpy-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:cd052f1fa6a78dee696b58a914b7229ecfa41f0a6d96dc663c1220a55e137593", size = 20951527, upload-time = "2025-09-09T15:57:52.006Z" },
+ { url = "https://files.pythonhosted.org/packages/ef/d8/204e0d73fc1b7a9ee80ab1fe1983dd33a4d64a4e30a05364b0208e9a241a/numpy-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:414a97499480067d305fcac9716c29cf4d0d76db6ebf0bf3cbce666677f12652", size = 14186159, upload-time = "2025-09-09T15:57:54.407Z" },
+ { url = "https://files.pythonhosted.org/packages/22/af/f11c916d08f3a18fb8ba81ab72b5b74a6e42ead4c2846d270eb19845bf74/numpy-2.3.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:50a5fe69f135f88a2be9b6ca0481a68a136f6febe1916e4920e12f1a34e708a7", size = 5114624, upload-time = "2025-09-09T15:57:56.5Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/11/0ed919c8381ac9d2ffacd63fd1f0c34d27e99cab650f0eb6f110e6ae4858/numpy-2.3.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:b912f2ed2b67a129e6a601e9d93d4fa37bef67e54cac442a2f588a54afe5c67a", size = 6642627, upload-time = "2025-09-09T15:57:58.206Z" },
+ { url = "https://files.pythonhosted.org/packages/ee/83/deb5f77cb0f7ba6cb52b91ed388b47f8f3c2e9930d4665c600408d9b90b9/numpy-2.3.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9e318ee0596d76d4cb3d78535dc005fa60e5ea348cd131a51e99d0bdbe0b54fe", size = 14296926, upload-time = "2025-09-09T15:58:00.035Z" },
+ { url = "https://files.pythonhosted.org/packages/77/cc/70e59dcb84f2b005d4f306310ff0a892518cc0c8000a33d0e6faf7ca8d80/numpy-2.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce020080e4a52426202bdb6f7691c65bb55e49f261f31a8f506c9f6bc7450421", size = 16638958, upload-time = "2025-09-09T15:58:02.738Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/5a/b2ab6c18b4257e099587d5b7f903317bd7115333ad8d4ec4874278eafa61/numpy-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e6687dc183aa55dae4a705b35f9c0f8cb178bcaa2f029b241ac5356221d5c021", size = 16071920, upload-time = "2025-09-09T15:58:05.029Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/f1/8b3fdc44324a259298520dd82147ff648979bed085feeacc1250ef1656c0/numpy-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d8f3b1080782469fdc1718c4ed1d22549b5fb12af0d57d35e992158a772a37cf", size = 18577076, upload-time = "2025-09-09T15:58:07.745Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/a1/b87a284fb15a42e9274e7fcea0dad259d12ddbf07c1595b26883151ca3b4/numpy-2.3.3-cp314-cp314-win32.whl", hash = "sha256:cb248499b0bc3be66ebd6578b83e5acacf1d6cb2a77f2248ce0e40fbec5a76d0", size = 6366952, upload-time = "2025-09-09T15:58:10.096Z" },
+ { url = "https://files.pythonhosted.org/packages/70/5f/1816f4d08f3b8f66576d8433a66f8fa35a5acfb3bbd0bf6c31183b003f3d/numpy-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:691808c2b26b0f002a032c73255d0bd89751425f379f7bcd22d140db593a96e8", size = 12919322, upload-time = "2025-09-09T15:58:12.138Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/de/072420342e46a8ea41c324a555fa90fcc11637583fb8df722936aed1736d/numpy-2.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:9ad12e976ca7b10f1774b03615a2a4bab8addce37ecc77394d8e986927dc0dfe", size = 10478630, upload-time = "2025-09-09T15:58:14.64Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/df/ee2f1c0a9de7347f14da5dd3cd3c3b034d1b8607ccb6883d7dd5c035d631/numpy-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9cc48e09feb11e1db00b320e9d30a4151f7369afb96bd0e48d942d09da3a0d00", size = 21047987, upload-time = "2025-09-09T15:58:16.889Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/92/9453bdc5a4e9e69cf4358463f25e8260e2ffc126d52e10038b9077815989/numpy-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:901bf6123879b7f251d3631967fd574690734236075082078e0571977c6a8e6a", size = 14301076, upload-time = "2025-09-09T15:58:20.343Z" },
+ { url = "https://files.pythonhosted.org/packages/13/77/1447b9eb500f028bb44253105bd67534af60499588a5149a94f18f2ca917/numpy-2.3.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:7f025652034199c301049296b59fa7d52c7e625017cae4c75d8662e377bf487d", size = 5229491, upload-time = "2025-09-09T15:58:22.481Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/f9/d72221b6ca205f9736cb4b2ce3b002f6e45cd67cd6a6d1c8af11a2f0b649/numpy-2.3.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:533ca5f6d325c80b6007d4d7fb1984c303553534191024ec6a524a4c92a5935a", size = 6737913, upload-time = "2025-09-09T15:58:24.569Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/5f/d12834711962ad9c46af72f79bb31e73e416ee49d17f4c797f72c96b6ca5/numpy-2.3.3-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0edd58682a399824633b66885d699d7de982800053acf20be1eaa46d92009c54", size = 14352811, upload-time = "2025-09-09T15:58:26.416Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/0d/fdbec6629d97fd1bebed56cd742884e4eead593611bbe1abc3eb40d304b2/numpy-2.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:367ad5d8fbec5d9296d18478804a530f1191e24ab4d75ab408346ae88045d25e", size = 16702689, upload-time = "2025-09-09T15:58:28.831Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/09/0a35196dc5575adde1eb97ddfbc3e1687a814f905377621d18ca9bc2b7dd/numpy-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8f6ac61a217437946a1fa48d24c47c91a0c4f725237871117dea264982128097", size = 16133855, upload-time = "2025-09-09T15:58:31.349Z" },
+ { url = "https://files.pythonhosted.org/packages/7a/ca/c9de3ea397d576f1b6753eaa906d4cdef1bf97589a6d9825a349b4729cc2/numpy-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:179a42101b845a816d464b6fe9a845dfaf308fdfc7925387195570789bb2c970", size = 18652520, upload-time = "2025-09-09T15:58:33.762Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/c2/e5ed830e08cd0196351db55db82f65bc0ab05da6ef2b72a836dcf1936d2f/numpy-2.3.3-cp314-cp314t-win32.whl", hash = "sha256:1250c5d3d2562ec4174bce2e3a1523041595f9b651065e4a4473f5f48a6bc8a5", size = 6515371, upload-time = "2025-09-09T15:58:36.04Z" },
+ { url = "https://files.pythonhosted.org/packages/47/c7/b0f6b5b67f6788a0725f744496badbb604d226bf233ba716683ebb47b570/numpy-2.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b37a0b2e5935409daebe82c1e42274d30d9dd355852529eab91dab8dcca7419f", size = 13112576, upload-time = "2025-09-09T15:58:37.927Z" },
+ { url = "https://files.pythonhosted.org/packages/06/b9/33bba5ff6fb679aa0b1f8a07e853f002a6b04b9394db3069a1270a7784ca/numpy-2.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:78c9f6560dc7e6b3990e32df7ea1a50bbd0e2a111e05209963f5ddcab7073b0b", size = 10545953, upload-time = "2025-09-09T15:58:40.576Z" },
+]
+
+[[package]]
+name = "picosdk"
+version = "1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9b/73/6ac7ab8eea102673173026adcde758127f5623cbd0c40987bbed27485e25/picosdk-1.1.tar.gz", hash = "sha256:b6dc68f3a1ae6f044421bf728b8b6f38145403607006e9c014705559d914d6f1", size = 115676, upload-time = "2022-08-25T22:08:03.156Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/50/e3/318adb98bdb872f328e4911312764f97ee4e0746edcf0b77138f79d43a16/picosdk-1.1-py2.py3-none-any.whl", hash = "sha256:be0d51b3561f99b16f026990915f51c207b6e347bbb9ded1130466e40734a4db", size = 75775, upload-time = "2022-08-25T22:07:57.465Z" },
+]
+
+[[package]]
+name = "picostream"
+version = "0.2.0"
+source = { editable = "." }
+dependencies = [
+ { name = "click" },
+ { name = "h5py" },
+ { name = "loguru" },
+ { name = "numba" },
+ { name = "numpy" },
+ { name = "picosdk" },
+ { name = "pyqt5" },
+ { name = "pyqtgraph" },
+]
+
+[package.metadata]
+requires-dist = [
+ { name = "click" },
+ { name = "h5py" },
+ { name = "loguru" },
+ { name = "numba" },
+ { name = "numpy" },
+ { name = "picosdk" },
+ { name = "pyqt5" },
+ { name = "pyqtgraph" },
+]
+
+[[package]]
+name = "pyqt5"
+version = "5.15.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "pyqt5-qt5" },
+ { name = "pyqt5-sip" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/07/c9ed0bd428df6f87183fca565a79fee19fa7c88c7f00a7f011ab4379e77a/PyQt5-5.15.11.tar.gz", hash = "sha256:fda45743ebb4a27b4b1a51c6d8ef455c4c1b5d610c90d2934c7802b5c1557c52", size = 3216775, upload-time = "2024-07-19T08:39:57.756Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/11/64/42ec1b0bd72d87f87bde6ceb6869f444d91a2d601f2e67cd05febc0346a1/PyQt5-5.15.11-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:c8b03dd9380bb13c804f0bdb0f4956067f281785b5e12303d529f0462f9afdc2", size = 6579776, upload-time = "2024-07-19T08:39:19.775Z" },
+ { url = "https://files.pythonhosted.org/packages/49/f5/3fb696f4683ea45d68b7e77302eff173493ac81e43d63adb60fa760b9f91/PyQt5-5.15.11-cp38-abi3-macosx_11_0_x86_64.whl", hash = "sha256:6cd75628f6e732b1ffcfe709ab833a0716c0445d7aec8046a48d5843352becb6", size = 7016415, upload-time = "2024-07-19T08:39:32.977Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/8c/4065950f9d013c4b2e588fe33cf04e564c2322842d84dbcbce5ba1dc28b0/PyQt5-5.15.11-cp38-abi3-manylinux_2_17_x86_64.whl", hash = "sha256:cd672a6738d1ae33ef7d9efa8e6cb0a1525ecf53ec86da80a9e1b6ec38c8d0f1", size = 8188103, upload-time = "2024-07-19T08:39:40.561Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/f0/ae5a5b4f9b826b29ea4be841b2f2d951bcf5ae1d802f3732b145b57c5355/PyQt5-5.15.11-cp38-abi3-win32.whl", hash = "sha256:76be0322ceda5deecd1708a8d628e698089a1cea80d1a49d242a6d579a40babd", size = 5433308, upload-time = "2024-07-19T08:39:46.932Z" },
+ { url = "https://files.pythonhosted.org/packages/56/d5/68eb9f3d19ce65df01b6c7b7a577ad3bbc9ab3a5dd3491a4756e71838ec9/PyQt5-5.15.11-cp38-abi3-win_amd64.whl", hash = "sha256:bdde598a3bb95022131a5c9ea62e0a96bd6fb28932cc1619fd7ba211531b7517", size = 6865864, upload-time = "2024-07-19T08:39:53.572Z" },
+]
+
+[[package]]
+name = "pyqt5-qt5"
+version = "5.15.17"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d3/f9/accb06e76e23fb23053d48cc24fd78dec6ed14cb4d5cbadb0fd4a0c1b02e/PyQt5_Qt5-5.15.17-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:d8b8094108e748b4bbd315737cfed81291d2d228de43278f0b8bd7d2b808d2b9", size = 39972275, upload-time = "2025-05-24T11:15:42.259Z" },
+ { url = "https://files.pythonhosted.org/packages/87/1a/e1601ad6934cc489b8f1e967494f23958465cf1943712f054c5a306e9029/PyQt5_Qt5-5.15.17-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b68628f9b8261156f91d2f72ebc8dfb28697c4b83549245d9a68195bd2d74f0c", size = 37135109, upload-time = "2025-05-24T11:15:59.786Z" },
+ { url = "https://files.pythonhosted.org/packages/ac/e1/13d25a9ff2ac236a264b4603abaa39fa8bb9a7aa430519bb5f545c5b008d/PyQt5_Qt5-5.15.17-py3-none-manylinux2014_x86_64.whl", hash = "sha256:b018f75d1cc61146396fa5af14da1db77c5d6318030e5e366f09ffdf7bd358d8", size = 61112954, upload-time = "2025-05-24T11:16:26.036Z" },
+]
+
+[[package]]
+name = "pyqt5-sip"
+version = "12.17.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/08/88a20c862f40b5c178c517cdc7e93767967dec5ac1b994e226d517991c9b/pyqt5_sip-12.17.1.tar.gz", hash = "sha256:0eab72bcb628f1926bf5b9ac51259d4fa18e8b2a81d199071135458f7d087ea8", size = 104136, upload-time = "2025-10-08T09:04:19.893Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a5/15/291f83f336558300626bebb0c403084ec171bbc8a70683e3376234422eb6/pyqt5_sip-12.17.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:c362606de782d2d46374a38523632786f145c517ee62de246a6069e5f2c5f336", size = 124521, upload-time = "2025-10-08T09:04:15.825Z" },
+ { url = "https://files.pythonhosted.org/packages/45/85/ea1ae099260fd1859d71b31f51760b4226abfa778d5796b76d92c8fe6dcd/pyqt5_sip-12.17.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:140cc582151456103ebb149fefc678f3cae803e7720733db51212af5219cd45c", size = 282182, upload-time = "2025-10-08T09:15:35.752Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/b3/d5b50c721651a0f2ccbef6f8db3dabf3db296b9ec239ba007f5615f57dd7/pyqt5_sip-12.17.1-cp312-cp312-win32.whl", hash = "sha256:9dc1f1525d4d42c080f6cfdfc70d78239f8f67b0a48ea0745497251d8d848b1d", size = 49447, upload-time = "2025-10-08T09:11:24.843Z" },
+ { url = "https://files.pythonhosted.org/packages/14/b6/474d8b17763683ab45fb364f3a44f25fdc25d97b47b29ad8819b95a15ac8/pyqt5_sip-12.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:d5e2e9e175559017cd161d661e0ee0b551684f824bb90800c5a8c8a3bea9355e", size = 57946, upload-time = "2025-10-08T09:08:35.775Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/58/9ecb688050e79ffe7bbd9fc917aa13f63856a5081ac46bbce87bb11ab971/pyqt5_sip-12.17.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9ebbd7769ccdaaa6295e9c872553b6cde17f38e171056f17300d8af9a14d1fc8", size = 124485, upload-time = "2025-10-08T09:04:17.473Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/9f/ae691360a9f18e3e06fd297e854d7ad175367e35ea184fd2fcf6c79b8c25/pyqt5_sip-12.17.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:b023da906a70af2cf5e6fc1932f441ede07530f3e164dd52c6c2bb5ab7c6f424", size = 281923, upload-time = "2025-10-08T09:15:37.004Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/31/491c45423174a359a4b8a8d84a7b541c453f48497ae928cbe4006bcd3e01/pyqt5_sip-12.17.1-cp313-cp313-win32.whl", hash = "sha256:36dbef482bd638786b909f3bda65b7b3d5cbd6cbf16797496de38bae542da307", size = 49400, upload-time = "2025-10-08T09:11:25.769Z" },
+ { url = "https://files.pythonhosted.org/packages/64/61/e28681dd5200094f7b2e6671e85c02a4d6693da36d23ad7d39ffbc70b15c/pyqt5_sip-12.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:d04e5551bbc3bcec98acc63b3b0618ddcbf31ff107349225b516fe7e7c0a7c8b", size = 57979, upload-time = "2025-10-08T09:08:37.036Z" },
+ { url = "https://files.pythonhosted.org/packages/71/f9/06c09dc94474ffe3f518f80e47fc69d34abf8e4a971ae7e7c667d6ff30a7/pyqt5_sip-12.17.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c49918287e1ad77956d1589f1d3d432a0be7630c646ea02cf652413a48e14458", size = 124400, upload-time = "2025-10-08T08:38:23.927Z" },
+ { url = "https://files.pythonhosted.org/packages/40/ae/be6e338ea427deac5cd81a93f51ae3fb6505d99d6d5e5d5341bcc099327e/pyqt5_sip-12.17.1-cp314-cp314-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:944a4bf1e1ee18ad03a54964c1c6433fb6de582313a1f0b17673e7203e22fc83", size = 282291, upload-time = "2025-10-08T08:38:25.735Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/a3/8b758518bd0dd5d1581f7a6d522c9b4d9b58d05087b1d0b4dfaad5376434/pyqt5_sip-12.17.1-cp314-cp314-win32.whl", hash = "sha256:99a2935fd662a67748625b1e6ffa0a2d1f2da068b9df6db04fa59a4a5d4ee613", size = 50578, upload-time = "2025-10-08T08:38:28.72Z" },
+ { url = "https://files.pythonhosted.org/packages/40/8c/e96f9877548810b1e537f46fc21ba74552dd4e8c498658114a8353bdf659/pyqt5_sip-12.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:aaa33232cc80793d14fdb3b149b27eec0855612ed66aad480add5ac49b9cee63", size = 59763, upload-time = "2025-10-08T08:38:27.443Z" },
+]
+
+[[package]]
+name = "pyqtgraph"
+version = "0.13.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/33/d9/b62d5cddb3caa6e5145664bee5ed90223dee23ca887ed3ee479f2609e40a/pyqtgraph-0.13.7.tar.gz", hash = "sha256:64f84f1935c6996d0e09b1ee66fe478a7771e3ca6f3aaa05f00f6e068321d9e3", size = 2343380, upload-time = "2024-04-29T02:18:58.467Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7b/34/5702b3b7cafe99be1d94b42f100e8cc5e6957b761fcb1cf5f72d492851da/pyqtgraph-0.13.7-py3-none-any.whl", hash = "sha256:7754edbefb6c367fa0dfb176e2d0610da3ada20aa7a5318516c74af5fb72bf7a", size = 1925473, upload-time = "2024-04-29T02:18:56.206Z" },
+]
+
+[[package]]
+name = "win32-setctime"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b3/8f/705086c9d734d3b663af0e9bb3d4de6578d08f46b1b101c2442fd9aecaa2/win32_setctime-1.2.0.tar.gz", hash = "sha256:ae1fdf948f5640aae05c511ade119313fb6a30d7eabe25fef9764dca5873c4c0", size = 4867, upload-time = "2024-12-07T15:28:28.314Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e1/07/c6fe3ad3e685340704d314d765b7912993bcb8dc198f0e7a89382d37974b/win32_setctime-1.2.0-py3-none-any.whl", hash = "sha256:95d644c4e708aba81dc3704a116d8cbc974d70b3bdb8be1d150e36be6e9d1390", size = 4083, upload-time = "2024-12-07T15:28:26.465Z" },
+]
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-13 22:57:57 +0000