Merge pull request #1172 from zdomke/dev_plot_fetch_data

ENH: ArchiveTimePlot Fetch Data on X-Axis Change

Author: jbellister-slac

pydm/widgets/archiver_time_plot.py

@@ -817,11 +817,17 @@ class PyDMArchiverTimePlot(PyDMTimePlot):
         The parent of this widget.
     init_y_channels : list
         A list of scalar channels to plot vs time.
-    background: str
+    background : str
         The background color for the plot.  Accepts any arguments that
         pyqtgraph.mkColor will accept.
-    optimized_data_bins: int
+    optimized_data_bins : int
         The number of bins of data returned from the archiver when using optimized requests
+    request_cooldown : int
+        The time, in milliseconds, between requests to the archiver appliance
+    cache_data : bool
+        Whether curves should retain archive data or fetch new data when the x-axis changes
+    show_all : bool
+        Shifts the x-axis range to show all data, or stay where the user set the x-axis to
     """
 
     def __init__(
@@ -830,6 +836,9 @@ def __init__(
         init_y_channels: List[str] = [],
         background: str = "default",
         optimized_data_bins: int = 2000,
+        request_cooldown: int = 1000,
+        cache_data: bool = True,
+        show_all: bool = True,
     ):
         super(PyDMArchiverTimePlot, self).__init__(
             parent=parent,
@@ -838,56 +847,104 @@ def __init__(
             background=background,
             bottom_axis=DateAxisItem("bottom"),
         )
+        self._cache_data = None
+
         self.optimized_data_bins = optimized_data_bins
+        self.request_cooldown = request_cooldown
+        self.cache_data = cache_data
+        self._show_all = show_all  # Show all plotted data after archiver fetch
+
         self._starting_timestamp = time.time()  # The timestamp at which the plot was first rendered
         self._min_x = self._starting_timestamp - DEFAULT_TIME_SPAN
         self._prev_x = self._min_x  # Holds the minimum x-value of the previous update of the plot
         self._archive_request_queued = False
         self.setTimeSpan(DEFAULT_TIME_SPAN)
 
-    def updateXAxis(self, update_immediately: bool = False) -> None:
+    @property
+    def cache_data(self):
+        """Returns if the curves of the plot are caching archive data or
+        fetching new archive data on every change to the x-axis"""
+        return self._cache_data
+
+    @cache_data.setter
+    def cache_data(self, enable: bool):
+        """If true, the curves on the plot will keep thier most recently fetched archive data. New
+        data will only be fetched when users navigate to an "unseen" section of the plot.
+        When false, the curves will fetch new archive data on every change to the x-axis.
+        """
+        if self._cache_data == enable:
+            return
+        if enable:
+            try:
+                self.plotItem.sigXRangeChanged.disconnect(self.updateXAxis)
+                self.plotItem.sigXRangeChangedManually.disconnect(self.updateXAxis)
+            except TypeError:
+                pass
+        else:
+            self.plotItem.sigXRangeChanged.connect(self.updateXAxis)
+            self.plotItem.sigXRangeChangedManually.connect(self.updateXAxis)
+        self._cache_data = enable
+
+    def updateXAxis(self) -> None:
         """Manages the requests to archiver appliance. When the user pans or zooms the x axis to the left,
         a request will be made for backfill data"""
-        if len(self._curves) == 0 or self.auto_scroll_timer.isActive():
+        if not self._curves:
             return
 
-        min_x = self.plotItem.getAxis("bottom").range[0]  # Gets the leftmost timestamp displayed on the x-axis
-        max_x = self.plotItem.getAxis("bottom").range[1]
-        max_point = max([curve.max_x() for curve in self._curves])
-        if min_x == 0:  # This is zero when the plot first renders
-            self._max_x = time.time()
-            self._min_x = self._max_x - DEFAULT_TIME_SPAN
-            self._starting_timestamp = self._max_x
-            if self.getTimeSpan() != MIN_TIME_SPAN:
-                # Initialize x-axis based on the time span as well as trigger a call to the archiver below
-                self._min_x = self._min_x - self.getTimeSpan()
+        min_x, max_x = self.plotItem.getAxis("bottom").range  # Get current visible x-axis range
+        if min_x == 0:  # Initial render case
+            self._initialize_x_axis()
+        elif not self._cache_data:
+            self._handle_caching_off(min_x, max_x)
+        elif not self.plotItem.isAnyXAutoRange():
+            self._handle_manual_scrolling_or_zoom(min_x, max_x)
+
+        self._prev_x = min_x
+
+    def _initialize_x_axis(self) -> None:
+        """Initializes the x-axis for the first render."""
+        self._max_x = time.time()
+        self._min_x = self._max_x - DEFAULT_TIME_SPAN
+        self._starting_timestamp = self._max_x
+
+        if self.getTimeSpan() != MIN_TIME_SPAN:
+            self._min_x -= self.getTimeSpan()
+            self._archive_request_queued = True
+            self.requestDataFromArchiver()
+
+        blocked = self.plotItem.blockSignals(True)
+        self.plotItem.setXRange(self._min_x, self._max_x, padding=0.0, update=False)
+        self.plotItem.blockSignals(blocked)
+
+    def _handle_caching_off(self, min_x: float, max_x: float) -> None:
+        """Handles the situation when there is no cached data and the user has changed the x-axis range."""
+        if min_x != self._min_x or max_x != self._max_x:
+            self._min_x = min_x
+            self._max_x = max_x
+            self.setTimeSpan(max_x - min_x)
+            if not self._archive_request_queued:
                 self._archive_request_queued = True
-                self.requestDataFromArchiver()
-            self.plotItem.setXRange(
-                time.time() - DEFAULT_TIME_SPAN, time.time(), padding=0.0, update=update_immediately
-            )
-        elif min_x < self._min_x and not self.plotItem.isAnyXAutoRange():
-            # This means the user has manually scrolled to the left, so request archived data
+                QTimer.singleShot(self.request_cooldown, self.requestDataFromArchiver)
+
+    def _handle_manual_scrolling_or_zoom(self, min_x: float, max_x: float) -> None:
+        """Handles scenarios of manual scrolling or zooming when autorange is disabled."""
+        max_point = max(curve.max_x() for curve in self._curves)
+
+        if min_x < self._min_x:
+            # User scrolled to the left, request archived data
             self._min_x = min_x
             self.setTimeSpan(max_point - min_x)
             if not self._archive_request_queued:
-                # Letting the user pan or scroll the plot is convenient, but can generate a lot of events in under
-                # a second that would trigger a request for data. By using a timer, we avoid this burst of events
-                # and consolidate what would be many requests to archiver into just one.
                 self._archive_request_queued = True
-                QTimer.singleShot(1000, self.requestDataFromArchiver)
-        # Here we only update the x-axis if the user hasn't asked for autorange and they haven't zoomed in (as
-        # detected by the max range showing on the plot being less than the data available)
-        elif not self.plotItem.isAnyXAutoRange() and max_x >= max_point - 10:
-            if min_x > (self._prev_x + 15) or min_x < (self._prev_x - 15):
-                # The plus/minus 15 just makes sure we don't do this on every update tick of the graph
+                QTimer.singleShot(self.request_cooldown, self.requestDataFromArchiver)
+        elif max_x >= max_point - 10:
+            # Check if we should update the x-axis
+            if abs(min_x - self._prev_x) > 15:
                 self.setTimeSpan(max_point - min_x)
             else:
-                # Keep the plot moving with a rolling window based on the current timestamp
-                self.plotItem.setXRange(
-                    max_point - self.getTimeSpan(), max_point, padding=0.0, update=update_immediately
-                )
-        self._prev_x = min_x
+                blocked = self.plotItem.blockSignals(True)
+                self.plotItem.setXRange(max_point - self.getTimeSpan(), max_point, padding=0.0, update=False)
+                self.plotItem.blockSignals(blocked)
 
     def requestDataFromArchiver(self, min_x: Optional[float] = None, max_x: Optional[float] = None) -> None:
         """
@@ -911,8 +968,10 @@ def requestDataFromArchiver(self, min_x: Optional[float] = None, max_x: Optional
             if curve.use_archive_data:
                 if max_x is None:
                     max_x = curve.min_x()
+                if not self._cache_data:
+                    max_x = min(max_x, self._max_x)
                 requested_seconds = max_x - min_x
-                if requested_seconds <= 5:
+                if requested_seconds <= MIN_TIME_SPAN:
                     continue  # Avoids noisy requests when first rendering the plot
                 # Max amount of raw data to return before using optimized data
                 max_data_request = int(0.80 * self.getArchiveBufferSize())
@@ -963,7 +1022,7 @@ def createCurveItem(self, *args, **kwargs) -> ArchivePlotCurveItem:
     def archive_data_received(self):
         """Take any action needed when this plot receives new data from archiver appliance"""
         self._archive_request_queued = False
-        if self.auto_scroll_timer.isActive():
+        if self.auto_scroll_timer.isActive() or not self._show_all:
             return
 
         max_x = max([curve.max_x() for curve in self._curves])