plasma-app 2.2.4__tar.gz → 2.3.0__tar.gz

{plasma_app-2.2.4 → plasma_app-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plasma-app
-Version: 2.2.4
+Version: 2.3.0
 Summary: PLASMA — Platform for LSL-based Acquisition of Sensor Metrics and Analytics
 License: MIT
 Project-URL: Homepage, https://github.com/YuyiChang/PLASMA

{plasma_app-2.2.4 → plasma_app-2.3.0}/plasma/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.2.4"
+__version__ = "2.3.0"
 
 # Short git commit hash baked in by CI (.github/workflows/build.yml) just
 # before a release build is frozen with PyInstaller — a frozen bundle ships no

{plasma_app-2.2.4 → plasma_app-2.3.0}/plasma/__main__.py

@@ -6,6 +6,7 @@ import gradio as gr
 from plasma import plugins
 from plasma.app_context import app_context
 from plasma.integrated_panel import IntegratedPanel
+from plasma.task_buzzer import BUZZER_JS
 from plasma.config import device_config
 from plasma import api as plasma_api
 
@@ -99,6 +100,25 @@ function refresh() {
     });
     obs.observe(document.body, {childList: true, subtree: true});
     window.addEventListener('pagehide', () => obs.disconnect(), {once: true});
+""" + BUZZER_JS + """
+    // SPACE starts a ready task only while its controls are visible. Let
+    // inputs, buttons and other keyboard controls retain their native behavior.
+    const taskKey = (event) => {
+        if (event.code !== 'Space' || event.repeat || event.altKey ||
+            event.ctrlKey || event.metaKey || event.shiftKey) return;
+        if (event.target.closest('input, textarea, button, select, a, [role="tab"], [contenteditable="true"]')) return;
+        for (const control of document.querySelectorAll('#plasma-task-start, #plasma-focus-task-start')) {
+            const button = control.matches('button') ? control : control.querySelector('button');
+            if (button && !button.disabled && button.getClientRects().length) {
+                event.preventDefault();
+                unlockAudio();
+                button.click();
+                break;
+            }
+        }
+    };
+    document.addEventListener('keydown', taskKey);
+    window.addEventListener('pagehide', () => document.removeEventListener('keydown', taskKey), {once: true});
 }
 """
 
@@ -107,11 +127,15 @@ def build_blocks(ip):
     the given `IntegratedPanel`. Shared by `main()` and the screenshot-capture
     tool (`scripts/capture_screenshots.py`) so both build the identical UI.
     Does not launch the server."""
-    with gr.Blocks(title=app_context().app_name, theme=gr.themes.Ocean(), js=js_func) as app:
+    with gr.Blocks(title=app_context().app_name, theme=gr.themes.Ocean(), js=js_func,
+                   css="#plasma-focus-memo {max-height: calc(100vh - 180px); overflow-y: auto;} "
+                       "#plasma-buzzer-event {display:none;}") as app:
         yams_title = None
         with gr.Tabs() as top_tabs:
             with gr.Tab("Session Dashboard"):
                 ip.interface()
+            with gr.Tab("Focus"):
+                ip.focus_interface()
             with gr.Tab("Data Dashboard"):
                 ip.visualizer_interface()
             # extra tabs contributed by enabled plugins (e.g. MSense SQC / IMU).
@@ -134,6 +158,8 @@ def build_blocks(ip):
             #     pl.interface()
 
         _wire_plot_timer_gate(ip, top_tabs, yams_title)
+        ip.wire_session_views(top_tabs)
+        ip.wire_task_buzzer()
 
         # stop any live MSense stream when the last browser tab goes away — a
         # continuous stream with nobody watching just churns the BLE radio and

{plasma_app-2.2.4 → plasma_app-2.3.0}/plasma/integrated_panel.py

@@ -1,4 +1,5 @@
 import atexit
+import csv
 import gradio as gr
 import struct
 import os
@@ -7,6 +8,8 @@ import html as _html
 import re
 from plasma.lsl_session import encode_participant, SessionInfo
 from plasma.journal import open_journal_outlet
+from plasma.task_sequence import TaskSequence, read_tasks
+from plasma.task_buzzer import BUZZER_CONTROLS
 import logging, datetime, time
 from logging import Logger
 from plasma import plugins, __version__, build_info
@@ -64,16 +67,16 @@ def _fmt_elapsed(seconds):
 
 _MEMO_CSS = (
     "<style>"
-    f"#{MEMO_PANEL_ELEM_ID} .prose{{max-width:none}}"
-    f"#{MEMO_PANEL_ELEM_ID} .m-wrap{{font:13px/1.5 ui-monospace,Menlo,Consolas,monospace}}"
-    f"#{MEMO_PANEL_ELEM_ID} .m-hdr{{font-weight:600;margin:1px 0 5px}}"
-    f"#{MEMO_PANEL_ELEM_ID} .m-row{{margin:4px 0}}"
-    f"#{MEMO_PANEL_ELEM_ID} .m-name{{font-weight:600}}"
-    f"#{MEMO_PANEL_ELEM_ID} .m-tag{{opacity:.6;font-weight:400;margin-left:7px}}"
-    f"#{MEMO_PANEL_ELEM_ID} .m-sub{{color:#555;padding-left:18px;font-size:12px}}"
-    f"#{MEMO_PANEL_ELEM_ID} .m-sub.rec{{color:{_STATUS_HEX['guidance']}}}"
-    f"#{MEMO_PANEL_ELEM_ID} .m-sub.guidance{{color:{_STATUS_HEX['guidance']}}}"
-    f"#{MEMO_PANEL_ELEM_ID} .m-dim{{opacity:.55}}"
+    ".plasma-memo .prose{max-width:none}"
+    ".plasma-memo .m-wrap{font:13px/1.5 ui-monospace,Menlo,Consolas,monospace}"
+    ".plasma-memo .m-hdr{font-weight:600;margin:1px 0 5px}"
+    ".plasma-memo .m-row{margin:4px 0}"
+    ".plasma-memo .m-name{font-weight:600}"
+    ".plasma-memo .m-tag{opacity:.6;font-weight:400;margin-left:7px}"
+    ".plasma-memo .m-sub{color:#555;padding-left:18px;font-size:12px}"
+    f".plasma-memo .m-sub.rec{{color:{_STATUS_HEX['guidance']}}}"
+    f".plasma-memo .m-sub.guidance{{color:{_STATUS_HEX['guidance']}}}"
+    ".plasma-memo .m-dim{opacity:.55}"
     "</style>"
 )
 
@@ -185,6 +188,7 @@ class IntegratedPanel():
 
         # session task-marker LSL stream (None if liblsl is unavailable)
         self.journal_outlet = open_journal_outlet()
+        self.task_sequence = TaskSequence(self._sequence_marker)
 
         # built-in LSL -> XDF recorder (default on; see interface() checkbox).
         # Created fresh on each Start, kept after Stop so the memo panel can
@@ -214,6 +218,9 @@ class IntegratedPanel():
         atexit.register(self._atexit_cleanup)
 
     def _atexit_cleanup(self):
+        sequence = getattr(self, "task_sequence", None)
+        if sequence is not None:
+            sequence.end()
         rec = getattr(self, "lsl_recorder", None)
         if rec is not None:
             try:
@@ -233,6 +240,11 @@ class IntegratedPanel():
             self.journal_outlet.push_sample([msg])
         self.logger.info(f"JOURNAL: {msg}")
 
+    def _sequence_marker(self, msg):
+        if self.journal_outlet is None:
+            raise RuntimeError("PLASMA journal LSL stream is unavailable")
+        self.journal(msg)
+
     def visualizer_interface(self):
         with gr.Column():
             gr.Markdown(
@@ -444,24 +456,22 @@ class IntegratedPanel():
                     self.btn_start.click(self.start_collection)
                     self.btn_stop.click(self.stop_collection)
 
-                    
-
                 with gr.Accordion(label="🗒️ Journaler", open=False):
-                    j_free = gr.Text(label="Marker text", placeholder="free text",
-                                     show_label=False)
-                    with gr.Row():
-                        j_send = gr.Button("✍️ Send marker", variant="primary")
-                        j_flag = gr.Button("🚩 Flag", scale=0)
+                    with gr.Tabs():
+                        with gr.Tab("Manual markers"):
+                            j_free = gr.Text(label="Marker text", placeholder="free text",
+                                                show_label=False)
+                            with gr.Row():
+                                j_send = gr.Button("✍️ Send marker", variant="primary")
+                                j_flag = gr.Button("🚩 Flag", scale=0)
+                            j_send.click(self._record_journal, inputs=j_free, outputs=j_free)
+                            j_flag.click(self._flag_journal)
+                        with gr.Tab("Task sequence"):
+                            self._task_sequence_interface()
 
-                    j_send.click(self._record_journal, inputs=j_free, outputs=j_free)
-                    j_flag.click(self._flag_journal)
 
                 with gr.Accordion(label="ℹ️ Memo", open=True):
-                    self.memo_html = gr.HTML(self._render_memo(),
-                                            elem_id=MEMO_PANEL_ELEM_ID, padding=False)
-                    timer = gr.Timer(value=1)
-                    timer.tick(fn=self._render_memo, outputs=self.memo_html,
-                            show_progress="hidden")
+                    self.memo_html = self._memo_interface("Session Dashboard", MEMO_PANEL_ELEM_ID)
 
         # with gr.Accordion("Help", open=False):
         #     with open("./plasma/help.md") as f:
@@ -469,6 +479,139 @@ class IntegratedPanel():
         #         # print(help_txt)
         #     md = gr.Markdown(help_txt)
 
+    def focus_interface(self):
+        with gr.Row():
+            with gr.Column(scale=3, min_width=320):
+                self._task_sequence_interface(focus=True)
+            with gr.Column(scale=2, min_width=320):
+                gr.Markdown("### Memo")
+                self._memo_interface("Focus", "plasma-focus-memo")
+
+    def _register_session_view(self, tab, timer, refresh, outputs, state):
+        if not hasattr(self, "_session_views"):
+            self._session_views = []
+        self._session_views.append(dict(tab=tab, timer=timer, refresh=refresh,
+                                        outputs=outputs, state=state))
+
+    def wire_session_views(self, tabs):
+        """Only refresh the selected top-level view; repaint it on selection.
+
+        State caches belong to each browser and display, so one Memo cannot
+        consume the other display's update or suppress a new viewer's first paint.
+        """
+        for view in self._session_views:
+            def select(last, evt: gr.SelectData, view=view):
+                active = evt.value == view["tab"]
+                values = view["refresh"](last) if active else [gr.skip()] * len(view["outputs"])
+                return [gr.Timer(active=active), *values]
+            tabs.select(select, inputs=view["state"],
+                        outputs=[view["timer"], *view["outputs"]], show_progress="hidden")
+
+    def _memo_interface(self, tab, elem_id):
+        content = self._render_memo()
+        display = gr.HTML(content, elem_id=elem_id, elem_classes=["plasma-memo"], padding=False)
+        last = gr.State(content)
+        timer = gr.Timer(value=1, active=(tab == "Session Dashboard"))
+        outputs = [display, last]
+        timer.tick(self._memo_view_refresh, inputs=last, outputs=outputs, show_progress="hidden")
+        self._register_session_view(tab, timer, self._memo_view_refresh, outputs, last)
+        return display
+
+    def _memo_view_refresh(self, last):
+        content = self._render_memo()
+        return [gr.skip() if content == last else content, content]
+
+    def _buzzer_refresh(self, last):
+        completion = self.task_sequence.snapshot()["completion_id"]
+        event = f'<span data-completion-id="{completion}"></span>'
+        return [gr.skip() if last == completion else event, completion]
+
+    def wire_task_buzzer(self):
+        # One lightweight notification pump for the browser, independent of the
+        # selected tab. No audio data, device work, or extra task timers here.
+        event = gr.HTML(elem_id="plasma-buzzer-event", padding=False)
+        last = gr.State(None)
+        gr.Timer(value=0.5).tick(self._buzzer_refresh, inputs=last, outputs=[event, last],
+                                show_progress="hidden")
+
+    def _task_view_refresh(self, last):
+        snap = self.task_sequence.snapshot()
+        task = snap["task"]
+        name = _html.escape(task.name) if task else "Upload a CSV in Journaler to begin"
+        status = _html.escape(snap["status"])
+        error = _html.escape(snap["error"])
+        if self.journal_outlet is None:
+            error = "PLASMA journal LSL stream is unavailable. Tasks cannot start."
+        content = (f'<div style="text-align:center"><div>Task {snap["index"] + 1 if task else 0}'
+                   f' / {snap["total"]} · {status}</div>'
+                   f'<div style="font-size:3rem;font-variant-numeric:tabular-nums">'
+                   f'{snap["remaining"]}</div><h3>{name}</h3></div>')
+        if error:
+            content += f'<p role="alert">{error}</p>'
+        current = (content, task.instruction if task else "",
+                   bool(task) and snap["index"] > 0,
+                   bool(task) and snap["index"] < snap["total"] - 1,
+                   bool(task) and snap["status"] == "Ready" and self.journal_outlet is not None,
+                   snap["running"])
+        values = [gr.skip() if last is not None and last[i] == value
+                  else value if i < 2 else gr.update(interactive=value)
+                  for i, value in enumerate(current)]
+        return [*values, current]
+
+    def _task_sequence_interface(self, focus=False):
+        tab = "Focus" if focus else "Session Dashboard"
+        if not focus:
+            gr.Markdown("Drop a CSV with **Condition**, **Move_Instruction**, and **load** "
+                        "(seconds). Start collection first to save markers to XDF. "
+                        "All connected viewers share this task sequence.")
+            upload = gr.File(label="Task sequence CSV", file_types=[".csv"], type="filepath")
+        display = gr.HTML()
+        instruction = gr.Textbox(label="Move instruction", lines=4 if focus else 6,
+                                 max_lines=6 if focus else 20, interactive=False)
+        with gr.Row():
+            previous = gr.Button("← Previous", interactive=False)
+            following = gr.Button("Next →", interactive=False)
+        with gr.Row():
+            start = gr.Button("Start task (SPACE)", variant="primary", interactive=False,
+                              elem_id="plasma-focus-task-start" if focus else "plasma-task-start")
+            end = gr.Button("End task", interactive=False)
+        gr.HTML(BUZZER_CONTROLS, padding=False)
+        gr.Markdown("Previous/Next ends a running task and prepares the selected row. "
+                    "At 00:00 the task ends; advance and start the next task when ready.")
+        last = gr.State(None)
+        outputs = [display, instruction, previous, following, start, end, last]
+
+        def load(path, last):
+            try:
+                tasks = read_tasks(path) if path else []
+                self.task_sequence.load(tasks)
+            except (ValueError, OSError, UnicodeError, csv.Error) as exc:
+                gr.Warning(f"Cannot load task CSV: {exc}")
+            return self._task_view_refresh(last)
+
+        def action(name):
+            def callback(last):
+                try:
+                    if name == "previous":
+                        self.task_sequence.move(-1)
+                    elif name == "next":
+                        self.task_sequence.move(1)
+                    else:
+                        getattr(self.task_sequence, name)()
+                except Exception as exc:
+                    gr.Warning(f"Task action failed: {exc}")
+                return self._task_view_refresh(last)
+            return callback
+
+        if not focus:
+            upload.change(load, inputs=[upload, last], outputs=outputs, show_progress="hidden")
+        for button, name in [(previous, "previous"), (following, "next"),
+                             (start, "start"), (end, "end")]:
+            button.click(action(name), inputs=last, outputs=outputs, show_progress="hidden")
+        timer = gr.Timer(value=0.5, active=not focus)
+        timer.tick(self._task_view_refresh, inputs=last, outputs=outputs, show_progress="hidden")
+        self._register_session_view(tab, timer, self._task_view_refresh, outputs, last)
+
     def _refresh_devices(self):
         active = list(device_config.get_active_table().keys())
         return gr.CheckboxGroup(choices=active, value=active)
@@ -557,6 +700,7 @@ class IntegratedPanel():
 
     def stop_collection(self):
         self.sts = "Stopping..."
+        self.task_sequence.end()
         for dev in self.available_devices:
             try:
                 dev.stop()
@@ -619,9 +763,7 @@ class IntegratedPanel():
         return _status.STOPPED if self._collection_stopped is not None else _status.COLLECTING
 
     def _render_memo(self):
-        """HTML for the memo panel. Returns gr.skip() when nothing changed since
-        the last tick, so gr.HTML doesn't tear down + re-render its subtree
-        (which reads as a 1 Hz blink)."""
+        """Build Memo HTML; each display owns its own browser-local cache."""
         rec = self.lsl_recorder
         started = self._collection_started
         elapsed = None
@@ -633,9 +775,6 @@ class IntegratedPanel():
             rec.status() if rec is not None else None,
             ext_streams=self._external_lsl_streams(), elapsed=elapsed,
             phase=self.phase)
-        if html == getattr(self, "_memo_last", None):
-            return gr.skip()
-        self._memo_last = html
         return html
 
 
@@ -703,4 +842,4 @@ def get_logger(log_dir="data"):
                             file_handler,
                             logging.StreamHandler(),
                         ])
-    return logger
+    return logger

plasma_app-2.3.0/plasma/task_buzzer.py

@@ -0,0 +1,97 @@
+"""One browser-local audio handler for both task views."""
+
+BUZZER_CONTROLS = """
+<div style="display:flex;align-items:center;gap:16px;flex-wrap:wrap">
+  <button type="button" data-plasma-buzzer-test
+    style="padding:8px 16px;border:1px solid var(--border-color-primary);border-radius:8px;
+           background:var(--button-secondary-background-fill);color:var(--button-secondary-text-color)">
+    Test buzzer</button>
+  <span data-plasma-buzzer-status role="status" style="font-size:12px"></span>
+</div>
+"""
+
+BUZZER_JS = r"""
+    let audioContext = null;
+    let lastCompletion = null;
+    let buzzerMessage = '';
+    const buzzerStatus = (message) => {
+        buzzerMessage = message;
+        document.querySelectorAll('[data-plasma-buzzer-status]').forEach(el => {
+            if (el.textContent !== message) el.textContent = message;
+        });
+    };
+    const syncBuzzer = () => {
+        document.querySelectorAll('[data-plasma-buzzer-status]').forEach(el => {
+            if (el.textContent !== buzzerMessage) el.textContent = buzzerMessage;
+        });
+    };
+    const unlockAudio = () => {
+        try {
+            const Audio = window.AudioContext || window.webkitAudioContext;
+            if (!Audio) throw new Error('Web Audio unavailable');
+            if (!audioContext) audioContext = new Audio();
+            if (audioContext.state !== 'running') {
+                audioContext.resume().catch(() => buzzerStatus('Click Test buzzer to enable audio.'));
+            }
+        } catch (_) {
+            buzzerStatus('Browser audio unavailable.');
+        }
+    };
+    const playBuzzer = async (gesture = false) => {
+        if (!gesture && (!audioContext || audioContext.state !== 'running')) {
+            buzzerStatus('Click Test buzzer to enable audio.');
+            return;
+        }
+        unlockAudio();
+        if (!audioContext) return;
+        try {
+            await audioContext.resume();
+            if (audioContext.state !== 'running') throw new Error('Audio blocked');
+            const now = audioContext.currentTime;
+            for (const offset of [0, 0.3]) {
+                const oscillator = audioContext.createOscillator();
+                const gain = audioContext.createGain();
+                oscillator.type = 'sine';
+                oscillator.frequency.value = 880;
+                gain.gain.setValueAtTime(0, now + offset);
+                gain.gain.linearRampToValueAtTime(0.2, now + offset + 0.015);
+                gain.gain.linearRampToValueAtTime(0, now + offset + 0.22);
+                oscillator.connect(gain);
+                gain.connect(audioContext.destination);
+                oscillator.onended = () => { oscillator.disconnect(); gain.disconnect(); };
+                oscillator.start(now + offset);
+                oscillator.stop(now + offset + 0.23);
+            }
+            buzzerStatus('Buzzer played.');
+        } catch (_) {
+            buzzerStatus('Click Test buzzer to enable audio.');
+        }
+    };
+    const buzzerClick = (event) => {
+        if (event.target.closest('[data-plasma-buzzer-test]')) {
+            playBuzzer(true);
+        } else if (event.target.closest('#plasma-task-start, #plasma-focus-task-start')) {
+            unlockAudio();
+        }
+    };
+    const checkCompletion = () => {
+        const event = document.querySelector('#plasma-buzzer-event [data-completion-id]');
+        if (!event) return;
+        const id = Number(event.dataset.completionId);
+        if (!Number.isFinite(id)) return;
+        const previous = lastCompletion;
+        lastCompletion = id;
+        // First delivery is the baseline; never replay an old completion on load.
+        if (previous !== null && id > previous) playBuzzer();
+    };
+    const buzzerObserver = new MutationObserver(() => { syncBuzzer(); checkCompletion(); });
+    buzzerObserver.observe(document.body, {childList: true, subtree: true});
+    syncBuzzer();
+    checkCompletion();
+    document.addEventListener('click', buzzerClick);
+    window.addEventListener('pagehide', () => {
+        buzzerObserver.disconnect();
+        document.removeEventListener('click', buzzerClick);
+        if (audioContext) audioContext.close();
+    }, {once: true});
+"""

plasma_app-2.3.0/plasma/task_sequence.py

@@ -0,0 +1,130 @@
+"""CSV task sequences and a browser-independent, monotonic countdown."""
+import csv
+from dataclasses import dataclass
+import math
+import threading
+import time
+
+
+@dataclass(frozen=True)
+class Task:
+    name: str
+    instruction: str
+    seconds: float
+
+
+def read_tasks(path):
+    tasks = []
+    with open(path, encoding="utf-8-sig", newline="") as source:
+        reader = csv.DictReader(source)
+        required = {"Condition", "Move_Instruction", "load"}
+        missing = required - set(reader.fieldnames or [])
+        if missing:
+            raise ValueError("Missing CSV columns: " + ", ".join(sorted(missing)))
+        for row in reader:
+            name = (row.get("Condition") or "").strip()
+            try:
+                seconds = float(row.get("load") or "")
+            except (ValueError, TypeError):
+                seconds = float("nan")
+            if not name or not math.isfinite(seconds) or seconds <= 0:
+                raise ValueError(f"CSV row ending at line {reader.line_num}: "
+                                 "Condition must be nonempty and load must be a positive finite number.")
+            tasks.append(Task(name, (row.get("Move_Instruction") or "").replace("\\n", "\n"), seconds))
+    if not tasks:
+        raise ValueError("CSV contains no task rows.")
+    return tasks
+
+
+def format_remaining(seconds):
+    minutes, seconds = divmod(max(0, math.ceil(seconds)), 60)
+    return f"{minutes:02d}:{seconds:02d}"
+
+
+class TaskSequence:
+    """One shared sequence per acquisition panel; serialize markers and actions.
+
+    A daemon timer ends the task even when the browser stops polling. Generation
+    checks prevent a canceled timer from ending a subsequently started task.
+    """
+
+    def __init__(self, emit, clock=time.monotonic, timer_factory=threading.Timer):
+        self.emit = emit
+        self.clock = clock
+        self.timer_factory = timer_factory
+        self.lock = threading.RLock()
+        self.tasks = []
+        self.index = 0
+        self.status = "No CSV loaded"
+        self.deadline = None
+        self.timer = None
+        self.generation = 0
+        self.error = ""
+        self.completion_id = 0
+
+    def load(self, tasks):
+        with self.lock:
+            self._end()
+            self.tasks = list(tasks)
+            self.index = 0
+            self.status = "Ready" if tasks else "No CSV loaded"
+
+    def start(self):
+        with self.lock:
+            if not self.tasks or self.deadline is not None or self.status != "Ready":
+                return
+            self.error = ""
+            self.emit(f"[{self.tasks[self.index].name}] start")
+            self.deadline = self.clock() + self.tasks[self.index].seconds
+            self.status = "Running"
+            self.generation += 1
+            self.timer = self.timer_factory(self.tasks[self.index].seconds,
+                                            self._expire, args=(self.generation,))
+            self.timer.daemon = True
+            self.timer.start()
+
+    def _expire(self, generation):
+        with self.lock:
+            if generation == self.generation and self.deadline is not None:
+                self._end("Completed")
+
+    def _end(self, status="Ended"):
+        if self.deadline is None:
+            return
+        self.deadline = None
+        self.generation += 1
+        if self.timer is not None:
+            self.timer.cancel()
+            self.timer = None
+        self.status = status
+        if status == "Completed":
+            self.completion_id += 1
+        try:
+            self.emit(f"[{self.tasks[self.index].name}] end")
+        except Exception as exc:
+            self.error = f"End marker failed: {exc}"
+
+    def end(self):
+        with self.lock:
+            self._end()
+
+    def move(self, offset):
+        with self.lock:
+            target = self.index + offset
+            if not 0 <= target < len(self.tasks):
+                return
+            self._end()
+            self.index = target
+            self.status = "Ready"
+
+    def snapshot(self):
+        with self.lock:
+            if self.deadline is not None and self.clock() >= self.deadline:
+                self._end("Completed")
+            task = self.tasks[self.index] if self.tasks else None
+            remaining = (max(0, self.deadline - self.clock()) if self.deadline is not None
+                         else task.seconds if task and self.status == "Ready" else 0)
+            return dict(task=task, index=self.index, total=len(self.tasks),
+                        remaining=format_remaining(remaining), status=self.status,
+                        error=self.error, running=self.deadline is not None,
+                        completion_id=self.completion_id)

{plasma_app-2.2.4 → plasma_app-2.3.0}/plasma_app.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plasma-app
-Version: 2.2.4
+Version: 2.3.0
 Summary: PLASMA — Platform for LSL-based Acquisition of Sensor Metrics and Analytics
 License: MIT
 Project-URL: Homepage, https://github.com/YuyiChang/PLASMA

{plasma_app-2.2.4 → plasma_app-2.3.0}/plasma_app.egg-info/SOURCES.txt

@@ -17,6 +17,8 @@ plasma/lsl_util.py
 plasma/plot_util.py
 plasma/plugins.py
 plasma/status.py
+plasma/task_buzzer.py
+plasma/task_sequence.py
 plasma/xdf_writer.py
 plasma/__pyinstaller/__init__.py
 plasma/__pyinstaller/hook-plasma.py