ndscope 0.22.0__tar.gz → 0.22.2__tar.gz

{ndscope-0.22.0 → ndscope-0.22.2}/CHANGELOG.md

@@ -1,4 +1,36 @@
 # Changelog
+
+## NEXT
+
+- New "latched" user message system
+- Improved error messages
+- Gaps are more visible
+- Fixed bug where Y axis label could overlap tick marks
+- Fixed bug where --single-shot data exports, e.g. hdf5, would never complete
+- Added system to place markers on plots, then jump between markers.
+- Fix bug where arrakis data could be timestamped wrong
+- Add --arrakis (choose default Arrakis data source) and --arrakis-server (specify an arrakis server) options.
+
+## 0.22.0 - 2026-08-24
+
+- Add buttons to enable/disable Y cursors on all plots
+- Y axis autoscale preserved during time-axis-only actions
+- Use shift <mouse gesture> to constrain a mouse action to the time axis
+- Use ctrl <mouse gesture> to constrain a mouse action to the Y axis
+- Fixed downsampling so that zooming in on fast channels will show real resolution
+- Fixed exception when cancelling a Kerberos login
+- Allow full precision when entering scale and offsets for a channel
+- Set curved width now used when adding new plots
+- Use --replay-id and other new options to access Arrakis replay feature
+- LIGO_DATA_URL environment variable dropped.
+- NDSSERVER environment variable takes precedence over ARRAKIS_SERVER
+
+## 0.21.0 - 2026-03-12
+
+- Updated color scheme to pick colors with more contrast
+- Add scatter plot
+- Improved HDF5 export
+
 ## [0.20.7] - 2026-01-29
 (changes since 0.19)
 - Interface

{ndscope-0.22.0 → ndscope-0.22.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ndscope
-Version: 0.22.0
+Version: 0.22.2
 Summary: Next-generation NDS time series plotting
 Author-email: Jameson Graef Rollins <jameson.rollins@ligo.org>, Patrick Thomas <patrick.thomas@ligo.org>, Erik von Reis <erik.vonreis@ligo.org>
 Maintainer-email: Jameson Graef Rollins <jameson.rollins@ligo.org>, Patrick Thomas <patrick.thomas@ligo.org>, Erik von Reis <erik.vonreis@ligo.org>
@@ -18,7 +18,7 @@ Description-Content-Type: text/markdown
 License-File: COPYING
 License-File: COPYING-GPL-3
 Requires-Dist: cairosvg
-Requires-Dist: dttlib>=0.11.0
+Requires-Dist: dttlib>=0.11.3
 Requires-Dist: gpstime
 Requires-Dist: h5py
 Requires-Dist: matplotlib
@@ -32,6 +32,8 @@ Requires-Dist: rapidfuzz
 Requires-Dist: scipy
 Requires-Dist: setproctitle
 Requires-Dist: setuptools_scm
+Requires-Dist: tomlkit
+Requires-Dist: platformdirs
 Dynamic: license-file
 
 # Next-generation NDS oscilloscope

{ndscope-0.22.0 → ndscope-0.22.2}/ndscope/__main__.py

@@ -1,14 +1,24 @@
 from __future__ import division, unicode_literals
-from argparse import Namespace
-import os
-import sys
-import signal
-import logging
+
 import argparse
 import asyncio
+import logging
+import os
+import signal
+import sys
+from argparse import Namespace
+from typing import Any, Dict
+
 import pyqtgraph as pg
+from dttlib import PipInstant, Replay
+
 from .cache import DataCache
-from dttlib import Replay, PipInstant
+from .configuration.configuration import load_config, get_config
+from .data_source_determination import (
+    add_data_source_args,
+    parse_data_source_args,
+    get_first_data_source,
+)
 
 try:
     import yaml
@@ -22,16 +32,13 @@ except ImportError:
         pass
 
 
-from gpstime import gpstime, GPSTimeException
+from gpstime import GPSTimeException, gpstime
 
-from . import __version__
-from . import const
+from . import __version__, const
 from . import template as _template
-from .util import resolve_data_source
 from ._qt import create_app
-from .scope import NDScope
 from .exceptions import UnknownChannelError
-
+from .scope import NDScope
 
 logging.addLevelName(5, "DATA")
 logging.basicConfig(
@@ -41,7 +48,6 @@ logging.basicConfig(
 
 logger = logging.getLogger("MAIN")
 
-
 ##################################################
 
 
@@ -146,16 +152,19 @@ specifying the file as argument:
 
   ndscope foobar.hdf5
 
-The data source url can be provided in the ARRAKIS_SERVER environment 
-variable. The URL should in the form grpc://server:port for arrakis servers 
-or nds://server:port for nds servers. If NDSSERVER is defined, it will 
-override ARRAKIS_SERVER, then NDSSERVER=server:port will be used 
+The data source url can be provided in the ARRAKIS_SERVER environment
+variable. The URL should in the form grpc://server:port for arrakis servers
+or nds://server:port for nds servers. If NDSSERVER is defined, it will
+override ARRAKIS_SERVER, then NDSSERVER=server:port will be used
 (NDS servers only).
 
-The data source can be set with the --url option for either
+Use the --arrakis option to use the ARRAKIS_SERVER environment
+variable instead of the NDSSERVER variable.
+
+The data source can be set with the --arrakis-server or --url option for either
 Arrakis servers or nds servers
 
-  ndscope --url=grpc://ngdd.ligo-la.caltech.edu:31206 L1:FOO
+  ndscope --arrakis-server=grpc://ngdd.ligo-la.caltech.edu:31206 L1:FOO
 
   ndscope --url=nds://nds.ligo-la.caltech.edu:31200 L1:FOO
 
@@ -212,8 +221,7 @@ parser.add_argument(
     dest="time_window",
     help="time window scalar or tuple, in seconds",
 )
-tgroup = parser.add_mutually_exclusive_group()
-tgroup.add_argument(
+parser.add_argument(
     "--trend",
     choices=["auto", "raw", "sec", "min"],
     help="specify trend type, 'auto' auto-selects best trend for time span [default]",
@@ -317,10 +325,9 @@ parser.add_argument(
     help="specify initial window size",
 )
 parser.add_argument("--expand", action="store_true", help="expand control bar")
-parser.add_argument("--url", metavar="URL:PORT", help=f"Data source URL")
-parser.add_argument(
-    "--nds", metavar="HOST[:PORT]", help=f"NDS server [{const.NDSSERVER}]"
-)
+
+add_data_source_args(parser)
+
 parser.add_argument(
     "--gen-template",
     action="store_true",
@@ -378,6 +385,10 @@ def main():
     signal.signal(signal.SIGINT, signal.SIG_DFL)
     setproctitle(" ".join([PROG] + sys.argv[1:]))
 
+    # these are configuration values determined by arguments
+    # to be passed to the load_config function
+    args_conf = {}
+
     args = parser.parse_args()
 
     if args.usage:
@@ -489,6 +500,15 @@ def main():
     template["t0"] = t0
     template["time-window"] = window
 
+    ##########
+    # Parse data sources
+    args_conf.update(parse_data_source_args(args))
+
+    ##########
+    # args fully parsed.  Load configuration
+
+    load_config(args_conf)
+
     ##########
     # launch app
 
@@ -496,7 +516,8 @@ def main():
         print(yaml.safe_dump(template, default_style=False))
         sys.exit()
 
-    url_text = resolve_data_source(args.nds, args.url)
+    # only the first data source for now
+    url_text = get_first_data_source()
     logger.debug(f"url = {url_text}")
 
     # create cache here so we can start running channel searches

{ndscope-0.22.0 → ndscope-0.22.2}/ndscope/__version__.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.22.0'
-__version_tuple__ = version_tuple = (0, 22, 0)
+__version__ = version = '0.22.2'
+__version_tuple__ = version_tuple = (0, 22, 2)
 
-__commit_id__ = commit_id = 'ga7ac0d3a6'
+__commit_id__ = commit_id = 'g86e3ad200'

{ndscope-0.22.0 → ndscope-0.22.2}/ndscope/cache.py

@@ -1,22 +1,22 @@
 from enum import Enum
 import logging
-import collections
-import traceback
 import dttlib
 from threading import Lock
 import asyncio
 
 from qtpy import QtCore
-from qtpy.QtCore import Signal, Slot, QTimer  # type: ignore
+from qtpy.QtCore import Signal, Slot, QTimer
 
 from rapidfuzz import process, fuzz
 
-from .dtt.channel_trend_id import ChannelTrendId  # type: ignore
+from .dtt.channel_trend_id import ChannelTrendId
 
 from . import nds
 from .data import DataBuffer, DataBufferDict
 from .exceptions import UnknownChannelError
 from .dtt import DTT, AnalysisResult
+from .messages.dtt_messages import handle_dtt_messages
+from .messages.messages import set_error, clear_message
 
 from typing import TYPE_CHECKING, Set, Union, Optional, Tuple, Dict, List
 
@@ -47,6 +47,9 @@ class AtomicViewId(object):
         return old_val
 
 
+primed_cache_logger = logging.getLogger("PRIMEDCACHE")
+
+
 class PrimedCache(object):
     """Use with PrimedCache(DataCache):
     to ensure a DataCache is primed at the end of a block.
@@ -69,18 +72,30 @@ class CacheReadyState(Enum):
 
 
 class CacheReady(QtCore.QObject):
-    """A statemachine that attempts to meter data flow into the Qt main thread"""
+    """
+    A statemachine that attempts to meter data flow into the Qt main thread
+    """
 
     def __init__(self, delay_ms: int, cache: "DataCache"):
         """
-        param delay_sec: delay to introduce between re-priming and actually priing the cache to send data
+        param delay_sec: delay to introduce between re-priming and actually
+        firing the cache to send data
         """
         self.delay_ms = delay_ms
         self.cache = cache
-        self.state = CacheReadyState.Primed
+        self._state = CacheReadyState.Primed
         self.state_lock = Lock()
         self.commands: List[str] = []
 
+    @property
+    def state(self):
+        return self._state
+
+    @state.setter
+    def state(self, new_state: CacheReadyState):
+        primed_cache_logger.debug("Transitioning from %s to %s", self.state, new_state)
+        self._state = new_state
+
     def _add_command(self, command: str):
         if len(self.commands) == 0:
             self.commands = [command]
@@ -145,6 +160,7 @@ class CacheReady(QtCore.QObject):
         """
         if len(self.commands) > 0:
             c = self.commands.pop()
+            logger.debug("CacheReady firing")
             self.cache.signal_data.emit(c)
 
     def _start_delay(self):
@@ -189,7 +205,9 @@ class ViewParams:
             self.end,
         )
 
-    def __eq__(self, other: "ViewParams") -> bool:
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ViewParams):
+            return False
         return (
             (not self.force)
             and self.online == other.online
@@ -248,11 +266,15 @@ class DataCacheContext(object):
             raise ValueError("cache context exited more times than it entered.")
         if self.cache.next_view_params == self.cache.prev_view_params:
             return
-        if self.cache.next_view_params.needs_new_view(self.cache.prev_view_params):
-            self.cache._new_scope_view()
-        else:
-            self.cache._set_scope_view()
-        self.cache.signal_channel_change.emit(None)
+        try:
+            if self.cache.next_view_params.needs_new_view(self.cache.prev_view_params):
+                self.cache._new_scope_view()
+            else:
+                self.cache._set_scope_view()
+            self.cache.signal_channel_change.emit(None)
+            clear_message("cache_context")
+        except UnknownChannelError as e:
+            set_error("cache_context", str(e))
 
     def __getattr__(self, name):
         return self.cache.__getattribute__(name)
@@ -281,12 +303,6 @@ class DataCache(QtCore.QObject):
     # payload a TrendType
     signal_trend_change = Signal("PyQt_PyObject")
 
-    # status and error message from cache data stream
-    # payload is a single string
-    signal_stream_status = Signal("PyQt_PyObject")
-    signal_online_status = Signal("PyQt_PyObject")
-    signal_stream_error = Signal("PyQt_PyObject")
-
     # data buffer in response to data request
     # payload: tuple of
     #   trend type string
@@ -300,6 +316,7 @@ class DataCache(QtCore.QObject):
 
     def __init__(self, scope: "NDScope", url_text: str, replay: dttlib.Replay) -> None:
         super().__init__()
+
         # needed to get the channel list
         self.scope = scope
         self.next_view_params = ViewParams(
@@ -337,7 +354,7 @@ class DataCache(QtCore.QObject):
             url_text=url_text,
             replay=replay,
             scope_data_handler=self.handle_scope_result,
-            message_handler=self._handle_messages,
+            message_handler=self._handle_dtt_messages,
             scope_view_done_handler=self._handle_view_done,
         )
 
@@ -384,7 +401,6 @@ class DataCache(QtCore.QObject):
         #         f"{k}: start = {d.gps_start} len = {len(d.data)} rate = {d.channel.rate_hz}"
         #     )
 
-        fire = False
         with self.data_lock:
             self.data_buffers.add_buffer(new_buffer)
             self.saved_data.add_buffer(new_buffer)
@@ -581,10 +597,8 @@ class DataCache(QtCore.QObject):
                 )
 
                 if self.next_view_params.online:
-                    msg = f"Retrieving {self._command_description('online', self.next_view_params.trend)}..."
                     self.view = self.dtt.new_online_scope_view(view_set, span_pip)
                 else:
-                    msg = f"Retrieving {self._command_description('', self.next_view_params.trend)}..."
                     if self.next_view_params.snapshot:
                         self.view = self.dtt.new_snapshot_scope_view(
                             view_set, start_pip, end_pip
@@ -734,22 +748,6 @@ class DataCache(QtCore.QObject):
 
     ##########
 
-    def _command_description(self, cmd, trend: dttlib.TrendType):
-        if cmd == "online":
-            desc = "online "
-        else:
-            desc = ""
-        if trend == "sec":
-            desc += "second trend data"
-        elif trend == "min":
-            desc += "minute trend data"
-        elif trend == "raw":
-            desc += "raw data"
-        return desc
-
-    def remote_cmd(self, cmd, **kwargs):
-        raise Exception("no longer used")
-
     def remote_recv_channels(self, channels: Union[str, Dict[str, "dttlib.Channel"]]):
         if isinstance(channels, str):
             # error message
@@ -760,7 +758,11 @@ class DataCache(QtCore.QObject):
             self.available_channels = channels
             self.signal_channel_list_ready.emit()
             if self.prime_invalid_recheck:
-                self._post_stream_message("Invalid channel")
+                user_message = dttlib.UserMessage(
+                    dttlib.Severity.Error, "Invalid channel"
+                )
+                msg_job = dttlib.MessageJob.SetMessage("stream_error", user_message)
+                self.handle_invalid_channels(msg_job)
 
     @Slot()
     def remote_done(self):
@@ -784,51 +786,6 @@ class DataCache(QtCore.QObject):
         await asyncio.gather(*tasks, return_exceptions=True)
         return set([task.result() for task in tasks if task.result()])
 
-    ##################################################################
-
-    def _handle_messages(self, msg: dttlib.MessageJob) -> None:
-        """
-        Handle incoming user messages from dttlib
-        """
-        logger.debug("msg=%s", str(msg))
-        if isinstance(msg, dttlib.MessageJob.SetMessage):
-            self.messages[msg.tag] = msg.msg
-        elif isinstance(msg, dttlib.MessageJob.ClearMessage):
-            if msg.tag in self.messages:
-                del self.messages[msg.tag]
-        else:
-            logger.info("Unknown message type %s", msg)
-        tag = msg.get_tag()
-        if tag == "stream_status":
-            self._handle_stream_status()
-        elif tag == "stream_error" or tag == "REQSIZE":
-            if (
-                not isinstance(msg, dttlib.MessageJob.SetMessage)
-                or msg.msg.severity >= dttlib.Severity.Error
-            ):
-                self._handle_stream_error()
-        elif tag == "online_status":
-            self._handle_online_status()
-        elif tag == "find_channels":
-            if "Request SASL authentication protocol" in str(msg):
-                self.signal_request_sasl.emit()
-        else:
-            logger.info("got unhandled message tag %s", tag)
-
-    def _handle_stream_status(self):
-        """ """
-        if "stream_status" in self.messages:
-            self._set_stream_status(self.messages["stream_status"].message)
-        else:
-            self._set_stream_status("")
-
-    def _handle_online_status(self):
-        """ """
-        if "online_status" in self.messages:
-            self._set_online_status(self.messages["online_status"].message)
-        else:
-            self._set_online_status("")
-
     def get_most_similar_channel(self, channel: str) -> Optional[str]:
         """Return the channel in available_channels that's string-wise most similar
 
@@ -902,25 +859,25 @@ class DataCache(QtCore.QObject):
                     msg = f"'{suspect}' is not valid for {trend}{online}"
         return msg
 
-    def _post_stream_message(self, msg):
-        self.prime_invalid_recheck = False
-        msg = self.guess_invalid_channel(msg)
-        self._set_stream_error(msg)
-
-    def _handle_stream_error(self):
-        """ """
-        if "stream_error" in self.messages:
-            self._post_stream_message(self.messages["stream_error"].message)
-        elif "REQSIZE" in self.messages:
-            self._set_stream_error(self.messages["REQSIZE"].message)
-        else:
-            self._set_stream_error("")
+    def _handle_dtt_messages(self, msg_job: dttlib.MessageJob):
+        if msg_job.get_tag() == "stream_error":
+            if isinstance(msg_job, dttlib.MessageJob.SetMessage):
+                msg_job = self.handle_invalid_channels(msg_job)
+        handle_dtt_messages(msg_job)
 
-    def _set_stream_status(self, status: str) -> None:
-        self.signal_stream_status.emit(status)
-
-    def _set_online_status(self, status: str) -> None:
-        self.signal_online_status.emit(status)
+    def handle_invalid_channels(
+        self, msg_job: dttlib.MessageJob.SetMessage
+    ) -> dttlib.MessageJob:
+        """
+        re-writes and re-sets an invalid channel message to include a guess at the correct channel
+        all other messages are passed through (and reset) unchanged.
 
-    def _set_stream_error(self, err: str) -> None:
-        self.signal_stream_error.emit(err)
+        This could potentially lead to a race where a message gets cleared and set very quickly.
+        """
+        self.prime_invalid_recheck = False
+        new_msg = self.guess_invalid_channel(msg_job.msg.message)
+        if new_msg != msg_job.msg.message:
+            new_msg = dttlib.UserMessage(msg_job.msg.severity, new_msg)
+            new_msg_job = dttlib.MessageJob.SetMessage(msg_job.tag, new_msg)
+            return new_msg_job
+        return msg_job

{ndscope-0.22.0 → ndscope-0.22.2}/ndscope/channel_select.py

@@ -13,6 +13,12 @@ from qtpy.QtCore import Signal  # type: ignore
 from ndscope.math_config import MathConfigDialog
 
 from ._qt import load_ui
+from .configuration.configuration import load_config
+from .data_source_determination import (
+    parse_data_source_args,
+    add_data_source_args,
+    get_first_data_source,
+)
 from .plot import NDScopePlotChannel
 
 from typing import TYPE_CHECKING, Set, List, Dict
@@ -1415,10 +1421,7 @@ def main():
         description=DESCRIPTION,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
-    parser.add_argument("--url", metavar="URL:PORT", help=f"Data source URL")
-    parser.add_argument(
-        "--nds", metavar="HOST[:PORT]", help=f"NDS server [{const.NDSSERVER}]"
-    )
+    add_data_source_args(parser)
     parser.add_argument(
         "glob",
         nargs="?",
@@ -1428,7 +1431,10 @@ def main():
 
     args = parser.parse_args()
 
-    url_text = util.resolve_data_source(args.nds, args.url)
+    args_conf = parse_data_source_args(args)
+    load_config(args_conf)
+
+    url_text = get_first_data_source()
 
     server, server_formatted = util.format_nds_server_string(url_text)
 
@@ -1447,7 +1453,7 @@ def main():
         logger.debug("done transform")
 
     dtt = dttlib.DTT(chans_callback)
-    cache = dttlib.NDS2Cache(1 << 30, "").as_ref()
+    cache = dttlib.NDS2Cache(1 << 30, "", url_text, dttlib.Replay.NoReplay()).as_ref()
     dtt.set_data_source(cache)
     logger.debug(
         f"Fetching channel list from {server} (channel glob: '{args.glob}')... "