Go Python 3.10+ in anticipation of upcoming feature PRs

piker/fsp/_engine.py

@@ -114,7 +114,7 @@ async def fsp_compute(
         dict[str, np.ndarray],  # multi-output case
         np.ndarray,  # single output case
     ]
-    history_output = await anext(out_stream)
+    history_output = await out_stream.__anext__()
 
     func_name = func.__name__
     profiler(f'{func_name} generated history')
@@ -374,8 +374,7 @@ async def cascade(
                             'key': dst_shm_token,
                             'first': dst._first.value,
                             'last': dst._last.value,
-                        }
+                    }})
-                    })
                     return tracker, index
 
                 def is_synced(

piker/ui/_chart.py

@@ -230,19 +230,18 @@ class GodWidget(QWidget):
             # - we'll probably want per-instrument/provider state here?
             #   change the order config form over to the new chart
 
+            # XXX: since the pp config is a singleton widget we have to
+            # also switch it over to the new chart's interal-layout
+            # self.linkedsplits.chart.qframe.hbox.removeWidget(self.pp_pane)
+            chart = linkedsplits.chart
+
             # chart is already in memory so just focus it
             linkedsplits.show()
             linkedsplits.focus()
             linkedsplits.graphics_cycle()
             await trio.sleep(0)
 
-            # XXX: since the pp config is a singleton widget we have to
-            # also switch it over to the new chart's interal-layout
-            # self.linkedsplits.chart.qframe.hbox.removeWidget(self.pp_pane)
-            chart = linkedsplits.chart
-
             # resume feeds *after* rendering chart view asap
-            if chart:
             chart.resume_all_feeds()
 
             # TODO: we need a check to see if the chart
@@ -761,18 +760,9 @@ class ChartPlotWidget(pg.PlotWidget):
 
         self.pi_overlay: PlotItemOverlay = PlotItemOverlay(self.plotItem)
 
-        # indempotent startup flag for auto-yrange subsys
-        # to detect the "first time" y-domain graphics begin
-        # to be shown in the (main) graphics view.
-        self._on_screen: bool = False
-
     def resume_all_feeds(self):
-        try:
         for feed in self._feeds.values():
             self.linked.godwidget._root_n.start_soon(feed.resume)
-        except RuntimeError:
-            # TODO: cancel the qtractor runtime here?
-            raise
 
     def pause_all_feeds(self):
         for feed in self._feeds.values():
@@ -869,8 +859,7 @@ class ChartPlotWidget(pg.PlotWidget):
 
     def default_view(
         self,
-        bars_from_y: int = 616,
+        bars_from_y: int = 3000,
-        do_ds: bool = True,
 
     ) -> None:
         '''
@@ -931,11 +920,8 @@ class ChartPlotWidget(pg.PlotWidget):
             max=end,
             padding=0,
         )
-
-        if do_ds:
         self.view.maybe_downsample_graphics()
         view._set_yrange()
-
         try:
             self.linked.graphics_cycle()
         except IndexError:
@@ -1269,6 +1255,7 @@ class ChartPlotWidget(pg.PlotWidget):
         If ``bars_range`` is provided use that range.
 
         '''
+        # print(f'Chart[{self.name}].maxmin()')
         profiler = pg.debug.Profiler(
             msg=f'`{str(self)}.maxmin(name={name})`: `{self.name}`',
             disabled=not pg_profile_enabled(),
@@ -1300,18 +1287,11 @@ class ChartPlotWidget(pg.PlotWidget):
 
             key = round(lbar), round(rbar)
             res = flow.maxmin(*key)
-
+            if res == (None, None):
-            if (
+                log.error(
-                res is None
-            ):
-                log.warning(
                     f"{flow_key} no mxmn for bars_range => {key} !?"
                 )
                 res = 0, 0
-                if not self._on_screen:
-                    self.default_view(do_ds=False)
-                    self._on_screen = True
 
         profiler(f'yrange mxmn: {key} -> {res}')
-        # print(f'{flow_key} yrange mxmn: {key} -> {res}')
         return res

piker/ui/_compression.py

@@ -223,20 +223,14 @@ def ds_m4(
     assert frames >= (xrange / uppx)
 
     # call into ``numba``
-    (
+    nb, i_win, y_out = _m4(
-        nb,
-        x_out,
-        y_out,
-        ymn,
-        ymx,
-    ) = _m4(
         x,
         y,
 
         frames,
 
         # TODO: see func below..
-        # x_out,
+        # i_win,
         # y_out,
 
         # first index in x data to start at
@@ -249,11 +243,10 @@ def ds_m4(
     # filter out any overshoot in the input allocation arrays by
     # removing zero-ed tail entries which should start at a certain
     # index.
-    x_out = x_out[x_out != 0]
+    i_win = i_win[i_win != 0]
-    y_out = y_out[:x_out.size]
+    y_out = y_out[:i_win.size]
 
-    # print(f'M4 output ymn, ymx: {ymn},{ymx}')
+    return nb, i_win, y_out
-    return nb, x_out, y_out, ymn, ymx
 
 
 @jit(
@@ -267,8 +260,8 @@ def _m4(
 
     frames: int,
 
-    # TODO: using this approach, having the ``.zeros()`` alloc lines
+    # TODO: using this approach by having the ``.zeros()`` alloc lines
-    # below in pure python, there were segs faults and alloc crashes..
+    # below, in put python was causing segs faults and alloc crashes..
     # we might need to see how it behaves with shm arrays and consider
     # allocating them once at startup?
 
@@ -281,22 +274,14 @@ def _m4(
     x_start: int,
     step: float,
 
-) -> tuple[
+) -> int:
-    int,
+    # nbins = len(i_win)
-    np.ndarray,
+    # count = len(xs)
-    np.ndarray,
-    float,
-    float,
-]:
-    '''
-    Implementation of the m4 algorithm in ``numba``:
-    http://www.vldb.org/pvldb/vol7/p797-jugel.pdf
 
-    '''
     # these are pre-allocated and mutated by ``numba``
     # code in-place.
     y_out = np.zeros((frames, 4), ys.dtype)
-    x_out = np.zeros(frames, xs.dtype)
+    i_win = np.zeros(frames, xs.dtype)
 
     bincount = 0
     x_left = x_start
@@ -310,34 +295,24 @@ def _m4(
 
     # set all bins in the left-most entry to the starting left-most x value
     # (aka a row broadcast).
-    x_out[bincount] = x_left
+    i_win[bincount] = x_left
     # set all y-values to the first value passed in.
     y_out[bincount] = ys[0]
 
-    # full input y-data mx and mn
-    mx: float = -np.inf
-    mn: float = np.inf
-
-    # compute OHLC style max / min values per window sized x-frame.
     for i in range(len(xs)):
-
         x = xs[i]
         y = ys[i]
-
         if x < x_left + step:   # the current window "step" is [bin, bin+1)
-            ymn = y_out[bincount, 1] = min(y, y_out[bincount, 1])
+            y_out[bincount, 1] = min(y, y_out[bincount, 1])
-            ymx = y_out[bincount, 2] = max(y, y_out[bincount, 2])
+            y_out[bincount, 2] = max(y, y_out[bincount, 2])
             y_out[bincount, 3] = y
-            mx = max(mx, ymx)
-            mn = min(mn, ymn)
-
         else:
             # Find the next bin
             while x >= x_left + step:
                 x_left += step
 
             bincount += 1
-            x_out[bincount] = x_left
+            i_win[bincount] = x_left
             y_out[bincount] = y
 
-    return bincount, x_out, y_out, mn, mx
+    return bincount, i_win, y_out

piker/ui/_display.py

@@ -105,10 +105,6 @@ def chart_maxmin(
     mn, mx = out
 
     mx_vlm_in_view = 0
-
-    # TODO: we need to NOT call this to avoid a manual
-    # np.max/min trigger and especially on the vlm_chart
-    # flows which aren't shown.. like vlm?
     if vlm_chart:
         out = vlm_chart.maxmin()
         if out:
@@ -226,9 +222,33 @@ async def graphics_update_loop(
     tick_margin = 3 * tick_size
 
     chart.show()
+    # view = chart.view
     last_quote = time.time()
     i_last = ohlcv.index
 
+    # async def iter_drain_quotes():
+    #     # NOTE: all code below this loop is expected to be synchronous
+    #     # and thus draw instructions are not picked up jntil the next
+    #     # wait / iteration.
+    #     async for quotes in stream:
+    #         while True:
+    #             try:
+    #                 moar = stream.receive_nowait()
+    #             except trio.WouldBlock:
+    #                 yield quotes
+    #                 break
+    #             else:
+    #                 for sym, quote in moar.items():
+    #                     ticks_frame = quote.get('ticks')
+    #                     if ticks_frame:
+    #                         quotes[sym].setdefault(
+    #                             'ticks', []).extend(ticks_frame)
+    #                     print('pulled extra')
+
+    #                 yield quotes
+
+    # async for quotes in iter_drain_quotes():
+
     ds = linked.display_state = DisplayState(**{
         'quotes': {},
         'linked': linked,
@@ -273,7 +293,6 @@ async def graphics_update_loop(
 
         # chart isn't active/shown so skip render cycle and pause feed(s)
         if chart.linked.isHidden():
-            print('skipping update')
             chart.pause_all_feeds()
             continue
 
@@ -397,8 +416,10 @@ def graphics_update_cycle(
             )
             or trigger_all
         ):
+            # TODO: we should track and compute whether the last
+            # pixel in a curve should show new data based on uppx
+            # and then iff update curves and shift?
             chart.increment_view(steps=i_diff)
-            # chart.increment_view(steps=i_diff + round(append_diff - uppx))
 
             if vlm_chart:
                 vlm_chart.increment_view(steps=i_diff)
@@ -456,6 +477,7 @@ def graphics_update_cycle(
         ):
             chart.update_graphics_from_flow(
                 chart.name,
+                # do_append=uppx < update_uppx,
                 do_append=do_append,
             )
 

piker/ui/_flows.py

@@ -337,7 +337,6 @@ class Flow(msgspec.Struct):  # , frozen=True):
     name: str
     plot: pg.PlotItem
     graphics: Union[Curve, BarItems]
-    yrange: tuple[float, float] = None
 
     # in some cases a flow may want to change its
     # graphical "type" or, "form" when downsampling,
@@ -387,11 +386,10 @@ class Flow(msgspec.Struct):  # , frozen=True):
         lbar: int,
         rbar: int,
 
-    ) -> Optional[tuple[float, float]]:
+    ) -> tuple[float, float]:
         '''
         Compute the cached max and min y-range values for a given
-        x-range determined by ``lbar`` and ``rbar`` or ``None``
+        x-range determined by ``lbar`` and ``rbar``.
-        if no range can be determined (yet).
 
         '''
         rkey = (lbar, rbar)
@@ -401,8 +399,9 @@ class Flow(msgspec.Struct):  # , frozen=True):
 
         shm = self.shm
         if shm is None:
-            return None
+            mxmn = None
 
+        else:  # new block for profiling?..
             arr = shm.array
 
             # build relative indexes into shm array
@@ -415,11 +414,7 @@ class Flow(msgspec.Struct):  # , frozen=True):
             ]
 
             if not slice_view.size:
-            return None
+                mxmn = None
-
-        elif self.yrange:
-            mxmn = self.yrange
-            # print(f'{self.name} M4 maxmin: {mxmn}')
 
             else:
                 if self.is_ohlc:
@@ -432,10 +427,9 @@ class Flow(msgspec.Struct):  # , frozen=True):
                     yhigh = np.max(view)
 
                 mxmn = ylow, yhigh
-            # print(f'{self.name} MANUAL maxmin: {mxmin}')
 
-        # cache result for input range
+            if mxmn is not None:
-        assert mxmn
+                # cache new mxmn result
                 self._mxmns[rkey] = mxmn
 
             return mxmn
@@ -634,13 +628,10 @@ class Flow(msgspec.Struct):  # , frozen=True):
             # source data so we clear our path data in prep
             # to generate a new one from original source data.
             new_sample_rate = True
+            showing_src_data = True
             should_ds = False
             should_redraw = True
 
-            showing_src_data = True
-            # reset yrange to be computed from source data
-            self.yrange = None
-
         # MAIN RENDER LOGIC:
         # - determine in view data and redraw on range change
         # - determine downsampling ops if needed
@@ -666,10 +657,6 @@ class Flow(msgspec.Struct):  # , frozen=True):
 
             **rkwargs,
         )
-        if showing_src_data:
-            # print(f"{self.name} SHOWING SOURCE")
-            # reset yrange to be computed from source data
-            self.yrange = None
 
         if not out:
             log.warning(f'{self.name} failed to render!?')
@@ -677,9 +664,6 @@ class Flow(msgspec.Struct):  # , frozen=True):
 
         path, data, reset = out
 
-        # if self.yrange:
-        #     print(f'flow {self.name} yrange from m4: {self.yrange}')
-
         # XXX: SUPER UGGGHHH... without this we get stale cache
         # graphics that don't update until you downsampler again..
         if reset:
@@ -1074,7 +1058,6 @@ class Renderer(msgspec.Struct):
         # xy-path data transform: convert source data to a format
         # able to be passed to a `QPainterPath` rendering routine.
         if not len(hist):
-            # XXX: this might be why the profiler only has exits?
             return
 
         x_out, y_out, connect = self.format_xy(
@@ -1161,14 +1144,11 @@ class Renderer(msgspec.Struct):
 
             elif should_ds and uppx > 1:
 
-                x_out, y_out, ymn, ymx = xy_downsample(
+                x_out, y_out = xy_downsample(
                     x_out,
                     y_out,
                     uppx,
                 )
-                self.flow.yrange = ymn, ymx
-                # print(f'{self.flow.name} post ds: ymn, ymx: {ymn},{ymx}')
-
                 reset = True
                 profiler(f'FULL PATH downsample redraw={should_ds}')
                 self._in_ds = True

piker/ui/_fsp.py

@@ -639,25 +639,20 @@ async def open_vlm_displays(
             names: list[str],
 
         ) -> tuple[float, float]:
-            '''
-            Flows "group" maxmin loop; assumes all named flows
-            are in the same co-domain and thus can be sorted
-            as one set.
 
-            Iterates all the named flows and calls the chart
-            api to find their range values and return.
-
-            TODO: really we should probably have a more built-in API
-            for this?
-
-            '''
             mx = 0
             for name in names:
-                ymn, ymx = chart.maxmin(name=name)
+
-                mx = max(mx, ymx)
+                mxmn = chart.maxmin(name=name)
+                if mxmn:
+                    ymax = mxmn[1]
+                    if ymax > mx:
+                        mx = ymax
 
             return 0, mx
 
+        chart.view.maxmin = partial(multi_maxmin, names=['volume'])
+
         # TODO: fix the x-axis label issue where if you put
         # the axis on the left it's totally not lined up...
         # show volume units value on LHS (for dinkus)
@@ -781,7 +776,6 @@ async def open_vlm_displays(
 
             ) -> None:
                 for name in names:
-
                     if 'dark' in name:
                         color = dark_vlm_color
                     elif 'rate' in name:

piker/ui/_interaction.py

@@ -923,7 +923,6 @@ class ChartView(ViewBox):
                     # XXX: super important to be aware of this.
                     # or not flow.graphics.isVisible()
                 ):
-                    # print(f'skipping {flow.name}')
                     continue
 
                 # pass in no array which will read and render from the last

piker/ui/_pathops.py

@@ -49,17 +49,12 @@ def xy_downsample(
 
     x_spacer: float = 0.5,
 
-) -> tuple[
+) -> tuple[np.ndarray, np.ndarray]:
-    np.ndarray,
-    np.ndarray,
-    float,
-    float,
-]:
 
     # downsample whenever more then 1 pixels per datum can be shown.
     # always refresh data bounds until we get diffing
     # working properly, see above..
-    bins, x, y, ymn, ymx = ds_m4(
+    bins, x, y = ds_m4(
         x,
         y,
         uppx,
@@ -72,7 +67,7 @@ def xy_downsample(
     )).flatten()
     y = y.flatten()
 
-    return x, y, ymn, ymx
+    return x, y
 
 
 @njit(

setup.py

@@ -57,6 +57,7 @@ setup(
         # from github currently (see requirements.txt)
         # 'trimeter',  # not released yet..
         # 'tractor',
+        # asyncvnc,
 
         # brokers
         'asks==2.4.8',
@@ -71,32 +72,34 @@ setup(
 
         # UI
         'PyQt5',
-        'pyqtgraph',
+        # 'pyqtgraph',  from our fork see reqs.txt
-        'qdarkstyle >= 3.0.2',
+        'qdarkstyle >= 3.0.2',  # themeing
-        # fuzzy search
+        'fuzzywuzzy[speedup]',  # fuzzy search
-        'fuzzywuzzy[speedup]',
 
         # tsdbs
-        'pymarketstore',
+        # anyio-marketstore  # from gh see reqs.txt
     ],
     extras_require={
-
-        # serialization
         'tsdb': [
             'docker',
         ],
 
     },
     tests_require=['pytest'],
-    python_requires=">=3.9",  # literally for ``datetime.datetime.fromisoformat``...
+    python_requires=">=3.10",
-    keywords=["async", "trading", "finance", "quant", "charting"],
+    keywords=[
+        "async",
+        "trading",
+        "finance",
+        "quant",
+        "charting",
+    ],
     classifiers=[
         'Development Status :: 3 - Alpha',
         'License :: OSI Approved :: ',
         'Operating System :: POSIX :: Linux',
         "Programming Language :: Python :: Implementation :: CPython",
         "Programming Language :: Python :: 3 :: Only",
-        "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         'Intended Audience :: Financial and Insurance Industry',
         'Intended Audience :: Science/Research',