Adjust feed status fields/display-pane to new actor-ID

That is to use the new `tractor.msg.types.Aid` struct to pull the
`brokerd` info from the `tractor.Channel.aid: Aid` attr as well as more
generally handling the new `Channel.raddr.proto_key: str` and no longer
assuming a TCP IPC transport; this per the recent `tractor.ipc`
subsys which adds multi-IPC-transports!

Downstream tweaks to match,
- use an "opt-in" field set to display in the `brokerd` info pane in
  `.ui._feedstatus.mk_feed_label()`.
 |_ also add some todos and drop some seemingly unneeded form sizing
    calcs?
- tweak `.ui._label` to allow not using markdown, though ended up not
  doing that since it looked too plain..

examples/max_pain.py

@@ -1,338 +0,0 @@
-#!/usr/bin/env python
-from decimal import (
-    Decimal,
-)
-from pathlib import Path
-
-import numpy as np
-# import polars as pl
-import trio
-import tractor
-from datetime import datetime
-# from pprint import pformat
-from piker.brokers.deribit.api import (
-    get_client,
-    maybe_open_oi_feed,
-)
-from piker.storage import open_storage_client, StorageClient
-from piker.log import get_logger
-import sys
-import pyqtgraph as pg
-from PyQt6 import QtCore
-from pyqtgraph import ScatterPlotItem, InfiniteLine
-from PyQt6.QtWidgets import QApplication
-from cryptofeed.symbols import Symbol
-
-
-log = get_logger(__name__)
-# XXX, use 2 newlines between top level LOC (even between these
-# imports and the next function line ;)
-
-def check_if_complete(
-        oi: dict[str, dict[str, Decimal | None]]
-    ) -> bool:
-    return all(
-        oi[strike]['C'] is not None
-        and
-        oi[strike]['P'] is not None for strike in oi
-    )
-
-
-async def max_pain_daemon(
-) -> None:
-    oi_by_strikes: dict[str, dict[str, Decimal | None]]
-    instruments: list[Symbol] = []
-    expiry_dates: list[str]
-    expiry_date: str
-    currency: str = 'btc'
-    kind: str = 'option'
-
-    async with get_client(
-    ) as client:
-        expiry_dates: list[str] = await client.get_expiration_dates(
-            currency=currency,
-            kind=kind
-        )
-
-        log.info(
-            f'Available expiries for {currency!r}-{kind}:\n'
-            f'{expiry_dates}\n'
-        )
-        expiry_date: str = input(
-            'Please enter a valid expiration date: '
-        ).upper()
-        print('Starting little daemon...')
-
-        # maybe move this type annot down to the assignment line?
-        oi_by_strikes: dict[str, dict[str, Decimal]]
-        instruments = await client.get_instruments(
-            expiry_date=expiry_date,
-        )
-        oi_by_strikes = client.get_strikes_dict(instruments)
-
-
-    def get_total_intrinsic_values(
-        oi_by_strikes: dict[str, dict[str, Decimal]]
-    ) -> dict[str, dict[str, Decimal]]:
-        call_cash: Decimal = Decimal(0)
-        put_cash: Decimal = Decimal(0)
-        intrinsic_values: dict[str, dict[str, Decimal]] = {}
-        closes: list = sorted(Decimal(close) for close in oi_by_strikes)
-
-        for strike, oi in oi_by_strikes.items():
-            s = Decimal(strike)
-            call_cash = sum(max(0, (s - c) * oi_by_strikes[str(c)]['C']) for c in closes)
-            put_cash = sum(max(0, (c - s) * oi_by_strikes[str(c)]['P']) for c in closes)
-
-            intrinsic_values[strike] = {
-                'C': call_cash,
-                'P': put_cash,
-                'total': call_cash + put_cash,
-            }
-
-        return intrinsic_values
-
-    def get_intrinsic_value_and_max_pain(
-        intrinsic_values: dict[str, dict[str, Decimal]]
-        ):
-        # We meed to find the lowest value, so we start at
-        # infinity to ensure that, and the max_pain must be
-        # an amount greater than zero.
-        total_intrinsic_value: Decimal = Decimal('Infinity')
-        max_pain: Decimal = Decimal(0)
-
-        for strike, oi in oi_by_strikes.items():
-            s = Decimal(strike)
-            if intrinsic_values[strike]['total'] < total_intrinsic_value:
-                total_intrinsic_value = intrinsic_values[strike]['total']
-                max_pain = s
-
-        return total_intrinsic_value, max_pain
-
-    def plot_graph(
-        oi_by_strikes: dict[str, dict[str, Decimal]],
-        plot,
-    ):
-        """Update the bar graph with new open interest data."""
-        plot.clear()
-
-        intrinsic_values = get_total_intrinsic_values(oi_by_strikes)
-
-        for strike_str in sorted(oi_by_strikes, key=lambda x: int(x)):
-            strike = int(strike_str)
-            calls_val = float(oi_by_strikes[strike_str]['C'])
-            puts_val  = float(oi_by_strikes[strike_str]['P'])
-
-            bar_c = pg.BarGraphItem(
-                x=[strike - 100],
-                height=[calls_val],
-                width=200,
-                pen='w',
-                brush=(0, 0, 255, 150)
-            )
-            plot.addItem(bar_c)
-
-            bar_p = pg.BarGraphItem(
-                x=[strike + 100],
-                height=[puts_val],
-                width=200,
-                pen='w',
-                brush=(255, 0, 0, 150)
-            )
-            plot.addItem(bar_p)
-
-            total_val = float(intrinsic_values[strike_str]['total']) / 100000
-
-            scatter_iv = ScatterPlotItem(
-                x=[strike],
-                y=[total_val],
-                pen=pg.mkPen(color=(0, 255, 0), width=2),
-                brush=pg.mkBrush(0, 255, 0, 150),
-                size=3,
-                symbol='o'
-            )
-            plot.addItem(scatter_iv)
-
-        _, max_pain = get_intrinsic_value_and_max_pain(intrinsic_values)
-
-        vertical_line = InfiniteLine(
-            pos=max_pain,
-            angle=90,
-            pen=pg.mkPen(color='yellow', width=1, style=QtCore.Qt.PenStyle.DotLine),
-            label=f'Max pain: {max_pain:,.0f}',
-            labelOpts={
-                'position': 0.85,
-                'color': 'yellow',
-                'movable': True
-            }
-        )
-        plot.addItem(vertical_line)
-
-    def update_oi_by_strikes(msg: tuple):
-        nonlocal oi_by_strikes
-        if 'oi' == msg[0]:
-            strike_price = msg[1]['strike_price']
-            option_type = msg[1]['option_type']
-            open_interest = msg[1]['open_interest']
-            oi_by_strikes.setdefault(
-                strike_price, {}
-            ).update(
-                {option_type: open_interest}
-            )
-
-    # Define the structured dtype
-    dtype = np.dtype([
-        ('time', int),
-        ('oi', float),
-        ('oi_calc', float),
-    ])
-    async def write_open_interest_on_file(msg: tuple, client: StorageClient):
-        if 'oi' == msg[0]:
-            nonlocal expiry_date
-            timestamp = msg[1]['timestamp']
-            strike_price = msg[1]["strike_price"]
-            option_type = msg[1]['option_type'].lower()
-            col_sym_key = f'btc-{expiry_date.lower()}-{strike_price}-{option_type}'
-
-            # Create the numpy array with sample data
-            data = np.array([
-                (
-                    int(timestamp),
-                    float(msg[1]['open_interest']),
-                    np.nan,
-                ),
-            ], dtype=dtype)
-
-            path: Path = await client.write_oi(
-                col_sym_key,
-                data,
-            )
-            # TODO, use std logging like this throughout for status
-            # emissions on console!
-            log.info(f'Wrote OI history to {path}')
-
-    def get_max_pain(
-        oi_by_strikes: dict[str, dict[str, Decimal]]
-    ) -> dict[str, str | Decimal]:
-        '''
-        This method requires only the strike_prices and oi for call
-        and puts, the closes list are the same as the strike_prices
-        the idea is to sum all the calls and puts cash for each strike
-        and the ITM strikes from that strike, the lowest value is what we
-        are looking for the intrinsic value.
-
-        '''
-
-        nonlocal timestamp
-
-        intrinsic_values = get_total_intrinsic_values(oi_by_strikes)
-
-        total_intrinsic_value, max_pain = get_intrinsic_value_and_max_pain(intrinsic_values)
-
-        return {
-            'timestamp': timestamp,
-            'expiry_date': expiry_date,
-            'total_intrinsic_value': total_intrinsic_value,
-            'max_pain': max_pain,
-        }
-
-    async with (
-        open_storage_client() as (_, storage),
-
-        maybe_open_oi_feed(
-            instruments,
-        ) as oi_feed,
-    ):
-        # Initialize QApplication
-        app = QApplication(sys.argv)
-
-        win = pg.GraphicsLayoutWidget(show=True)
-        win.setWindowTitle('Calls (blue) vs Puts (red)')
-
-        plot = win.addPlot(title='OI by Strikes')
-        plot.showGrid(x=True, y=True)
-        print('Plot initialized...')
-
-        async for msg in oi_feed:
-
-            # In memory oi_by_strikes dict, all message are filtered here
-            # and the dict is updated with the open interest data
-            update_oi_by_strikes(msg)
-
-            # Write on file using storage client
-            await write_open_interest_on_file(msg, storage)
-
-            # Max pain calcs, before start we must gather all the open interest for
-            # all the strike prices and option types available for a expiration date
-            if check_if_complete(oi_by_strikes):
-                if 'oi' == msg[0]:
-                    # Here we must read for the filesystem all the latest open interest value for
-                    # each instrument for that specific expiration date, that means look up for the
-                    # last update got the instrument btc-{expity_date}-*oi1s.parquet (1s because is
-                    # hardcoded to something, sorry.)
-                    timestamp = msg[1]['timestamp']
-                    max_pain = get_max_pain(oi_by_strikes)
-                    # intrinsic_values = get_total_intrinsic_values(oi_by_strikes)
-
-                    # graph here
-                    plot_graph(oi_by_strikes, plot)
-
-                    # TODO, use a single multiline string with `()`
-                    # and drop the multiple `print()` calls (this
-                    # should be done elsewhere in this file as well!
-                    #
-                    # As per the docs,
-                    # https://docs.python.org/3/reference/lexical_analysis.html#string-literal-concatenation
-                    # you could instead do,
-                    # print(
-                    #   '-----------------------------------------------\n'
-                    #   f'timestamp: {datetime.fromtimestamp(max_pain['timestamp'])}\n'
-                    # )
-                    # WHY?
-                    # |_ less ctx-switches/calls to `print()`
-                    # |_ the `str` can then be modified / passed
-                    #   around as a variable more easily if needed in
-                    #   the future ;)
-                    #
-                    # ALSO, i believe there already is a stdlib
-                    # module to do "alignment" of text which you
-                    # could try for doing the right-side alignment,
-                    # https://docs.python.org/3/library/textwrap.html#textwrap.indent
-                    #
-                    print('-----------------------------------------------')
-                    print(f'timestamp:             {datetime.fromtimestamp(max_pain['timestamp'])}')
-                    print(f'expiry_date:           {max_pain['expiry_date']}')
-                    print(f'max_pain:              {max_pain['max_pain']:,.0f}')
-                    print(f'total intrinsic value: {max_pain['total_intrinsic_value']:,.0f}')
-                    print('-----------------------------------------------')
-
-            # Process GUI events to keep the window responsive
-            app.processEvents()
-
-
-async def main():
-
-    async with tractor.open_nursery(
-        debug_mode=True,
-        loglevel='info',
-    ) as an:
-        from tractor import log
-        log.get_console_log(level='info')
-
-        ptl: tractor.Portal = await an.start_actor(
-            'max_pain_daemon',
-            enable_modules=[__name__],
-            infect_asyncio=True,
-            # ^TODO, we can actually run this in the root-actor now
-            # if needed as per 2nd "section" in,
-            # https://pikers.dev/goodboy/tractor/pulls/2
-            #
-            # NOTE, will first require us porting to modern
-            # `tractor:main` though ofc!
-
-        )
-        await ptl.run(max_pain_daemon)
-
-
-if __name__ == '__main__':
-    trio.run(main)

examples/max_pain_readme.rst

@@ -1,29 +0,0 @@
-## Max Pain Calculation for Deribit Options
-
-This feature, which calculates the max pain point for options traded
-on the Deribit exchange using cryptofeed library.
-
-- Functions in the api module for fetching options data from Deribit.
-  [commit](https://pikers.dev/pikers/piker/commit/da55856dd2876291f55a06eb0561438a912d8241)
-
-- Compute the max pain point based on open interest data using
-  deribit's api.
-  [commit](https://pikers.dev/pikers/piker/commit/0d9d6e15ba0edeb662ec97f7599dd66af3046b94)
-
-### How to test it?
-
-**Before start:** in order to get this working with `uv`,  you
-**must** use my [`tractor` fork](https://pikers.dev/ntorres/tractor/src/branch/aio_abandons)
-and this branch: `aio_abandons`, the reason is that I cherry-pick the
-`uv_migration` that guille made, for some reason that a didn't dive
-into, in my system y need tractor using `uv` too. quite hacky
-I guess.
-
-1. `uv lock`
-
-2. `uv run --no-dev python examples/max_pain.py`
-
-3. A message should be display, enter one of the expiration date
-   available.
-
-4. The script should be up and running.

piker/brokers/__init__.py

@@ -51,7 +51,6 @@ __brokers__: list[str] = [
     'ib',
     'kraken',
     'kucoin',
-    'deribit',
 
     # broken but used to work
     # 'questrade',
@@ -62,6 +61,7 @@ __brokers__: list[str] = [
     # wstrade
     # iex
 
+    # deribit
     # bitso
 ]
 

piker/brokers/deribit/__init__.py

@@ -25,7 +25,6 @@ from .api import (
     get_client,
 )
 from .feed import (
-    get_mkt_info,
     open_history_client,
     open_symbol_search,
     stream_quotes,
@@ -35,20 +34,15 @@ from .feed import (
     # open_trade_dialog,
     # norm_trade_records,
 # )
-from .venues import (
-    OptionPair,
-)
 
 log = get_logger(__name__)
 
 __all__ = [
     'get_client',
 #    'trades_dialogue',
-    'get_mkt_info',
     'open_history_client',
     'open_symbol_search',
     'stream_quotes',
-    'OptionPair',
 #    'norm_trade_records',
 ]
 

piker/brokers/deribit/feed.py

@@ -18,59 +18,38 @@
 Deribit backend.
 
 '''
-from __future__ import annotations
 from contextlib import asynccontextmanager as acm
 from datetime import datetime
-from typing import (
-    # Any,
-    # Optional,
-    Callable,
-)
-# from pprint import pformat
+from typing import Any, Optional, Callable
 import time
 
-import cryptofeed
 import trio
 from trio_typing import TaskStatus
-from pendulum import (
-    from_timestamp,
-)
+import pendulum
+from rapidfuzz import process as fuzzy
 import numpy as np
 import tractor
 
-from piker.accounting import (
-    Asset,
-    MktPair,
-    unpack_fqme,
-)
-from piker.brokers import (
-    open_cached_client,
-    NoData,
+from piker.brokers import open_cached_client
+from piker.log import get_logger, get_console_log
+from piker.data import ShmArray
+from piker.brokers._util import (
+    BrokerError,
     DataUnavailable,
 )
-from piker._cacheables import (
-    async_lifo_cache,
-)
-from piker.log import (
-    get_logger,
-    mk_repr,
-)
-from piker.data.validate import FeedInit
 
+from cryptofeed import FeedHandler
+from cryptofeed.defines import (
+    DERIBIT, L1_BOOK, TRADES, OPTION, CALL, PUT
+)
+from cryptofeed.symbols import Symbol
 
 from .api import (
-    Client,
-    # get_config,
-    piker_sym_to_cb_sym,
-    cb_sym_to_deribit_inst,
-    str_to_cb_sym,
+    Client, Trade,
+    get_config,
+    str_to_cb_sym, piker_sym_to_cb_sym, cb_sym_to_deribit_inst,
     maybe_open_price_feed
 )
-from .venues import (
-    Pair,
-    OptionPair,
-    Trade,
-)
 
 _spawn_kwargs = {
     'infect_asyncio': True,
@@ -85,215 +64,90 @@ async def open_history_client(
     mkt: MktPair,
 ) -> tuple[Callable, int]:
 
+    fnstrument: str = mkt.bs_fqme
     # TODO implement history getter for the new storage layer.
     async with open_cached_client('deribit') as client:
 
-        pair: OptionPair = client._pairs[mkt.dst.name]
-        # XXX NOTE, the cuckers use ms !!!
-        creation_time_s: int = pair.creation_timestamp/1000
-
         async def get_ohlc(
-            timeframe: float,
-            end_dt: datetime | None = None,
-            start_dt: datetime | None = None,
+            end_dt: Optional[datetime] = None,
+            start_dt: Optional[datetime] = None,
 
         ) -> tuple[
             np.ndarray,
             datetime,  # start
             datetime,  # end
         ]:
-            if timeframe != 60:
-                raise DataUnavailable('Only 1m bars are supported')
 
-            array: np.ndarray = await client.bars(
-                mkt,
+            array = await client.bars(
+                instrument,
                 start_dt=start_dt,
                 end_dt=end_dt,
             )
             if len(array) == 0:
-                if (
-                    end_dt is None
-                ):
-                    raise DataUnavailable(
-                        'No history seems to exist yet?\n\n'
-                        f'{mkt}'
-                    )
-                elif (
-                    end_dt
-                    and
-                    end_dt.timestamp() < creation_time_s
-                ):
-                    # the contract can't have history
-                    # before it was created.
-                    pair_type_str: str = type(pair).__name__
-                    create_dt: datetime = from_timestamp(creation_time_s)
-                    raise DataUnavailable(
-                        f'No history prior to\n'
-                        f'`{pair_type_str}.creation_timestamp: int = '
-                        f'{pair.creation_timestamp}\n\n'
-                        f'------ deribit sux ------\n'
-                        f'WHICH IN "NORMAL PEOPLE WHO USE EPOCH TIME" form is,\n'
-                        f'creation_time_s: {creation_time_s}\n'
-                        f'create_dt: {create_dt}\n'
-                    )
-                raise NoData(
-                    f'No frame for {start_dt} -> {end_dt}\n'
-                )
+                raise DataUnavailable
 
-            start_dt = from_timestamp(array[0]['time'])
-            end_dt = from_timestamp(array[-1]['time'])
-
-            times = array['time']
-            if not times.any():
-                raise ValueError(
-                    'Bad frame with null-times?\n\n'
-                    f'{times}'
-                )
-
-            if end_dt is None:
-                inow: int = round(time.time())
-                if (inow - times[-1]) > 60:
-                    await tractor.pause()
+            start_dt = pendulum.from_timestamp(array[0]['time'])
+            end_dt = pendulum.from_timestamp(array[-1]['time'])
 
             return array, start_dt, end_dt
 
-        yield (
-            get_ohlc,
-            {  # backfill config
-                'erlangs': 3,
-                'rate': 3,
-            }
-        )
-
-
-@async_lifo_cache()
-async def get_mkt_info(
-    fqme: str,
-
-) -> tuple[MktPair, Pair|OptionPair] | None:
-
-    # uppercase since kraken bs_mktid is always upper
-    if 'deribit' not in fqme.lower():
-        fqme += '.deribit'
-
-    mkt_mode: str = ''
-    broker, mkt_ep, venue, expiry = unpack_fqme(fqme)
-
-    # NOTE: we always upper case all tokens to be consistent with
-    # binance's symbology style for pairs, like `BTCUSDT`, but in
-    # theory we could also just keep things lower case; as long as
-    # we're consistent and the symcache matches whatever this func
-    # returns, always!
-    expiry: str = expiry.upper()
-    venue: str = venue.upper()
-    # venue_lower: str = venue.lower()
-
-    mkt_mode: str = 'option'
-
-    async with open_cached_client(
-        'deribit',
-    ) as client:
-
-        assets: dict[str, Asset] = await client.get_assets()
-        pair_str: str = mkt_ep.lower()
-
-        pair: Pair = await client.exch_info(
-            sym=pair_str,
-        )
-        mkt_mode = pair.venue
-        client.mkt_mode = mkt_mode
-
-        dst: Asset | None = assets.get(pair.bs_dst_asset)
-        src: Asset | None = assets.get(pair.bs_src_asset)
-
-        mkt = MktPair(
-            dst=dst,
-            src=src,
-            price_tick=pair.price_tick,
-            size_tick=pair.size_tick,
-            bs_mktid=pair.symbol,
-            venue=mkt_mode,
-            broker='deribit',
-            _atype=mkt_mode,
-            _fqme_without_src=True,
-
-            # expiry=pair.expiry,
-            # XXX TODO, currently we don't use it since it's
-            # already "described" in the `OptionPair.symbol: str`
-            # and if we slap in the ISO repr it's kinda hideous..
-            # -[ ] figure out the best either std
-        )
-        return mkt, pair
+        yield get_ohlc, {'erlangs': 3, 'rate': 3}
 
 
 async def stream_quotes(
+
     send_chan: trio.abc.SendChannel,
     symbols: list[str],
     feed_is_live: trio.Event,
+    loglevel: str = None,
 
     # startup sync
     task_status: TaskStatus[tuple[dict, dict]] = trio.TASK_STATUS_IGNORED,
 
 ) -> None:
-    '''
-    Open a live quote stream for the market set defined by `symbols`.
+    # XXX: required to propagate ``tractor`` loglevel to piker logging
+    get_console_log(loglevel or tractor.current_actor().loglevel)
 
-    Internally this starts a `cryptofeed.FeedHandler` inside an `asyncio`-side
-    task and relays through L1 and `Trade` msgs here to our `trio.Task`.
-
-    '''
-    sym = symbols[0].split('.')[0]
-    init_msgs: list[FeedInit] = []
-
-    # multiline nested `dict` formatter (since rn quote-msgs are
-    # just that).
-    pfmt: Callable[[str], str] = mk_repr(
-        # so we can see `deribit`'s delightfully mega-long bs fields..
-        maxstring=100,
-    )
+    sym = symbols[0]
 
     async with (
         open_cached_client('deribit') as client,
         send_chan as send_chan
     ):
-        mkt: MktPair
-        pair: Pair
-        mkt, pair = await get_mkt_info(sym)
 
-        # build out init msgs according to latest spec
-        init_msgs.append(
-            FeedInit(
-                mkt_info=mkt,
-            )
-        )
-        # build `cryptofeed` feed-handle
-        cf_sym: cryptofeed.Symbol = piker_sym_to_cb_sym(sym)
+        init_msgs = {
+            # pass back token, and bool, signalling if we're the writer
+            # and that history has been written
+            sym: {
+                'symbol_info': {
+                    'asset_type': 'option',
+                    'price_tick_size': 0.0005
+                },
+                'shm_write_opts': {'sum_tick_vml': False},
+                'fqsn': sym,
+            },
+        }
 
-        from_cf: tractor.to_asyncio.LinkedTaskChannel
-        async with maybe_open_price_feed(sym) as from_cf:
+        nsym = piker_sym_to_cb_sym(sym)
 
-            # load the "last trades" summary
-            last_trades_res: cryptofeed.LastTradesResult = await client.last_trades(
-                cb_sym_to_deribit_inst(cf_sym),
-                count=1,
-            )
-            last_trades: list[Trade] = last_trades_res.trades
+        async with maybe_open_price_feed(sym) as stream:
 
-            # TODO, do we even need this or will the above always
-            # work?
-            # if not last_trades:
-            #     await tractor.pause()
-            #     async for typ, quote in from_cf:
-            #         if typ == 'trade':
-            #             last_trade = Trade(**(quote['data']))
-            #             break
+            cache = await client.cache_symbols()
 
-            # else:
-            last_trade = Trade(
-                **(last_trades[0])
-            )
+            last_trades = (await client.last_trades(
+                cb_sym_to_deribit_inst(nsym), count=1)).trades
 
-            first_quote: dict = {
+            if len(last_trades) == 0:
+                last_trade = None
+                async for typ, quote in stream:
+                    if typ == 'trade':
+                        last_trade = Trade(**(quote['data']))
+                        break
+
+            else:
+                last_trade = Trade(**(last_trades[0]))
+
+            first_quote = {
                 'symbol': sym,
                 'last': last_trade.price,
                 'brokerd_ts': last_trade.timestamp,
@@ -304,84 +158,13 @@ async def stream_quotes(
                     'broker_ts': last_trade.timestamp
                 }]
             }
-            task_status.started((
-                init_msgs,
-                first_quote,
-            ))
+            task_status.started((init_msgs,  first_quote))
 
             feed_is_live.set()
 
-            # NOTE XXX, static for now!
-            # => since this only handles ONE mkt feed at a time we
-            # don't need a lookup table to map interleaved quotes
-            # from multiple possible mkt-pairs
-            topic: str = mkt.bs_fqme
-
-            # deliver until cancelled
-            async for typ, ref in from_cf:
-                match typ:
-                    case 'trade':
-                        trade: cryptofeed.types.Trade = ref
-
-                        # TODO, re-impl this according to teh ideal
-                        # fqme for opts that we choose!!
-                        bs_fqme: str = cb_sym_to_deribit_inst(
-                            str_to_cb_sym(trade.symbol)
-                        ).lower()
-
-                        piker_quote: dict = {
-                            'symbol': bs_fqme,
-                            'last': trade.price,
-                            'broker_ts': time.time(),
-                            # ^TODO, name this `brokerd/datad_ts` and
-                            # use `time.time_ns()` ??
-                            'ticks': [{
-                                'type': 'trade',
-                                'price': float(trade.price),
-                                'size': float(trade.amount),
-                                'broker_ts': trade.timestamp,
-                            }],
-                        }
-                        log.info(
-                            f'deribit {typ!r} quote for {sym!r}\n\n'
-                            f'{trade}\n\n'
-                            f'{pfmt(piker_quote)}\n'
-                        )
-
-                    case 'l1':
-                        book: cryptofeed.types.L1Book = ref
-
-                        # TODO, so this is where we can possibly change things
-                        # and instead lever the `MktPair.bs_fqme: str` output?
-                        bs_fqme: str = cb_sym_to_deribit_inst(
-                            str_to_cb_sym(book.symbol)
-                        ).lower()
-
-                        piker_quote: dict = {
-                            'symbol': bs_fqme,
-                            'ticks': [
-
-                                {'type': 'bid',
-                                 'price': float(book.bid_price),
-                                 'size': float(book.bid_size)},
-
-                                {'type': 'bsize',
-                                 'price': float(book.bid_price),
-                                 'size': float(book.bid_size),},
-
-                                {'type': 'ask',
-                                 'price': float(book.ask_price),
-                                 'size': float(book.ask_size),},
-
-                                {'type': 'asize',
-                                 'price': float(book.ask_price),
-                                 'size': float(book.ask_size),}
-                            ]
-                        }
-
-                await send_chan.send({
-                    topic: piker_quote,
-                })
+            async for typ, quote in stream:
+                topic = quote['symbol']
+                await send_chan.send({topic: quote})
 
 
 @tractor.context
@@ -391,21 +174,12 @@ async def open_symbol_search(
     async with open_cached_client('deribit') as client:
 
         # load all symbols locally for fast search
-        # cache = client._pairs
+        cache = await client.cache_symbols()
         await ctx.started()
 
         async with ctx.open_stream() as stream:
-            pattern: str
+
             async for pattern in stream:
-
-                # NOTE: pattern fuzzy-matching is done within
-                # the methd impl.
-                pairs: dict[str, Pair] = await client.search_symbols(
-                    pattern,
-                )
-                # repack in fqme-keyed table
-                byfqme: dict[str, Pair] = {}
-                for pair in pairs.values():
-                    byfqme[pair.bs_fqme] = pair
-
-                await stream.send(byfqme)
+                # repack in dict form
+                await stream.send(
+                    await client.search_symbols(pattern))

piker/brokers/deribit/venues.py

@@ -1,196 +0,0 @@
-# piker: trading gear for hackers
-# Copyright (C) Tyler Goodlet (in stewardship for pikers)
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-"""
-Per market data-type definitions and schemas types.
-
-"""
-from __future__ import annotations
-import pendulum
-from typing import (
-    Literal,
-    Optional,
-)
-from decimal import Decimal
-
-from piker.types import Struct
-
-
-# API endpoint paths by venue / sub-API
-_domain: str = 'deribit.com'
-_url = f'https://www.{_domain}'
-
-# WEBsocketz
-_ws_url: str = f'wss://www.{_domain}/ws/api/v2'
-
-# test nets
-_testnet_ws_url: str = f'wss://test.{_domain}/ws/api/v2'
-
-MarketType = Literal[
-    'option'
-]
-
-
-def get_api_eps(venue: MarketType) -> tuple[str, str]:
-    '''
-    Return API ep root paths per venue.
-
-    '''
-    return {
-        'option': (
-            _ws_url,
-        ),
-    }[venue]
-
-
-class Pair(Struct, frozen=True, kw_only=True):
-
-    symbol: str
-
-    # src
-    quote_currency: str # 'BTC'
-
-    # dst
-    base_currency: str # "BTC",
-
-    tick_size: float # 0.0001 # [{'above_price': 0.005, 'tick_size': 0.0005}]
-    tick_size_steps: list[dict[str, float]] 
-
-    @property
-    def price_tick(self) -> Decimal:
-        return Decimal(str(self.tick_size_steps[0]['above_price']))
-
-    @property
-    def size_tick(self) -> Decimal:
-        return Decimal(str(self.tick_size))
-
-    @property
-    def bs_fqme(self) -> str:
-        return f'{self.symbol}'
-
-    @property
-    def bs_mktid(self) -> str:
-        return f'{self.symbol}.{self.venue}'
-
-
-class OptionPair(Pair, frozen=True):
-
-    taker_commission: float # 0.0003
-    strike: float # 5000.0
-    settlement_period: str # 'day'
-    settlement_currency: str # "BTC",
-    rfq: bool # false
-    price_index: str # 'btc_usd'
-    option_type: str # 'call'
-    min_trade_amount: float # 0.1
-    maker_commission: float # 0.0003
-    kind: str # 'option'
-    is_active: bool # true
-    instrument_type: str # 'reversed'
-    instrument_name: str # 'BTC-1SEP24-55000-C'
-    instrument_id: int # 364671
-    expiration_timestamp: int # 1725177600000
-    creation_timestamp: int # 1724918461000
-    counter_currency: str # 'USD' 
-    contract_size: float # '1.0'
-    block_trade_tick_size: float # '0.0001'
-    block_trade_min_trade_amount: int # '25'
-    block_trade_commission: float # '0.003'
-
-    # NOTE: see `.data._symcache.SymbologyCache.load()` for why
-    ns_path: str = 'piker.brokers.deribit:OptionPair'
-
-    # TODO, impl this without the MM:SS part of
-    # the `'THH:MM:SS..'` etc..
-    @property
-    def expiry(self) -> str:
-        iso_date = pendulum.from_timestamp(
-            self.expiration_timestamp / 1000
-        ).isoformat()
-        return iso_date 
-
-    @property
-    def venue(self) -> str:
-        return f'{self.instrument_type}_option'
-
-    @property
-    def bs_fqme(self) -> str:
-        return f'{self.symbol}'
-
-    @property
-    def bs_src_asset(self) -> str:
-        return f'{self.quote_currency}'
-
-    @property
-    def bs_dst_asset(self) -> str:
-        return f'{self.symbol}'
-
-
-PAIRTYPES: dict[MarketType, Pair] = {
-    'option': OptionPair,
-}
-
-
-class JSONRPCResult(Struct):
-    id: int
-    usIn: int
-    usOut: int
-    usDiff: int
-    testnet: bool
-    jsonrpc: str = '2.0'
-    error: Optional[dict] = None
-    result: Optional[list[dict]] = None
-
-
-class JSONRPCChannel(Struct):
-    method: str
-    params: dict
-    jsonrpc: str = '2.0'
-
-
-class KLinesResult(Struct):
-    low: list[float]
-    cost: list[float]
-    high: list[float]
-    open: list[float]
-    close: list[float]
-    ticks: list[int]
-    status: str
-    volume: list[float]
-
-
-class Trade(Struct):
-    iv: float
-    price: float
-    amount: float
-    trade_id: str
-    contracts: float
-    direction: str
-    trade_seq: int
-    timestamp: int
-    mark_price: float
-    index_price: float
-    tick_direction: int
-    instrument_name: str
-    combo_id: Optional[str] = '',
-    combo_trade_id: Optional[int] = 0,
-    block_trade_id: Optional[str] = '',
-    block_trade_leg_count: Optional[int] = 0,
-
-
-class LastTradesResult(Struct):
-    trades: list[Trade]
-    has_more: bool

piker/brokers/ib/api.py

@@ -96,10 +96,6 @@ from ._util import (
     get_logger,
 )
 
-# ?TODO? this can now be removed since it was originally to extend
-# with a `bar_vwap` field that we removed from the default ohlcv
-# dtype since it's better calculated in an FSP func
-#
 _bar_load_dtype: list[tuple[str, type]] = [
     # NOTE XXX: only part that's diff
     # from our default fields where

piker/clearing/_client.py

@@ -171,7 +171,6 @@ class OrderClient(Struct):
 
 
 async def relay_orders_from_sync_code(
-
     client: OrderClient,
     symbol_key: str,
     to_ems_stream: tractor.MsgStream,
@@ -245,6 +244,11 @@ async def open_ems(
 
     async with maybe_open_emsd(
         broker,
+        # XXX NOTE, LOL so this determines the daemon `emsd` loglevel
+        # then FYI.. that's kinda wrong no?
+        # -[ ] shouldn't it be set by `pikerd -l` or no?
+        # -[ ] would make a lot more sense to have a subsys ctl for
+        #     levels.. like `-l emsd.info` or something?
         loglevel=loglevel,
     ) as portal:
 

piker/clearing/_ems.py

@@ -653,7 +653,11 @@ class Router(Struct):
             flume = feed.flumes[fqme]
             first_quote: dict = flume.first_quote
             book: DarkBook = self.get_dark_book(broker)
-            book.lasts[fqme]: float = float(first_quote['last'])
+
+            if not (last := first_quote.get('last')):
+                last: float = flume.rt_shm.array[-1]['close']
+
+            book.lasts[fqme]: float = float(last)
 
             async with self.maybe_open_brokerd_dialog(
                 brokermod=brokermod,
@@ -716,7 +720,7 @@ class Router(Struct):
             subs = self.subscribers[sub_key]
 
         sent_some: bool = False
-        for client_stream in subs:
+        for client_stream in subs.copy():
             try:
                 await client_stream.send(msg)
                 sent_some = True
@@ -1010,10 +1014,14 @@ async def translate_and_relay_brokerd_events(
                 status_msg.brokerd_msg = msg
                 status_msg.src = msg.broker_details['name']
 
-                await router.client_broadcast(
-                    status_msg.req.symbol,
-                    status_msg,
-                )
+                if not status_msg.req:
+                    # likely some order change state?
+                    await tractor.pause()
+                else:
+                    await router.client_broadcast(
+                        status_msg.req.symbol,
+                        status_msg,
+                    )
 
                 if status == 'closed':
                     log.info(f'Execution for {oid} is complete!')

piker/clearing/_paper_engine.py

@@ -297,6 +297,8 @@ class PaperBoi(Struct):
 
         # transmit pp msg to ems
         pp: Position = self.acnt.pps[bs_mktid]
+        # TODO, this will break if `require_only=True` was passed to
+        # `.update_from_ledger()`
 
         pp_msg = BrokerdPosition(
             broker=self.broker,

piker/clearing/_util.py

@@ -30,6 +30,7 @@ subsys: str = 'piker.clearing'
 
 log = get_logger(subsys)
 
+# TODO, oof doesn't this ignore the `loglevel` then???
 get_console_log = partial(
     get_console_log,
     name=subsys,

piker/data/_sampling.py

@@ -95,6 +95,12 @@ class Sampler:
     # history loading.
     incr_task_cs: trio.CancelScope | None = None
 
+    bcast_errors: tuple[Exception] = (
+        trio.BrokenResourceError,
+        trio.ClosedResourceError,
+        trio.EndOfChannel,
+    )
+
     # holds all the ``tractor.Context`` remote subscriptions for
     # a particular sample period increment event: all subscribers are
     # notified on a step.
@@ -258,14 +264,15 @@ class Sampler:
         subs: set
         last_ts, subs = pair
 
-        task = trio.lowlevel.current_task()
-        log.debug(
-            f'SUBS {self.subscribers}\n'
-            f'PAIR {pair}\n'
-            f'TASK: {task}: {id(task)}\n'
-            f'broadcasting {period_s} -> {last_ts}\n'
-            # f'consumers: {subs}'
-        )
+        # NOTE, for debugging pub-sub issues
+        # task = trio.lowlevel.current_task()
+        # log.debug(
+        #     f'AlL-SUBS@{period_s!r}: {self.subscribers}\n'
+        #     f'PAIR: {pair}\n'
+        #     f'TASK: {task}: {id(task)}\n'
+        #     f'broadcasting {period_s} -> {last_ts}\n'
+        #     f'consumers: {subs}'
+        # )
         borked: set[MsgStream] = set()
         sent: set[MsgStream] = set()
         while True:
@@ -282,13 +289,11 @@ class Sampler:
                         await stream.send(msg)
                         sent.add(stream)
 
-                    except (
-                        trio.BrokenResourceError,
-                        trio.ClosedResourceError,
-                        trio.EndOfChannel,
-                    ):
+                    except self.bcast_errors as err:
                         log.error(
-                            f'{stream._ctx.chan.uid} dropped connection'
+                            f'Connection dropped for IPC ctx\n'
+                            f'{stream._ctx}\n\n'
+                            f'Due to {type(err)}'
                         )
                         borked.add(stream)
                 else:
@@ -395,7 +400,8 @@ async def register_with_sampler(
                 finally:
                     if (
                         sub_for_broadcasts
-                        and subs
+                        and
+                        subs
                     ):
                         try:
                             subs.remove(stream)
@@ -562,8 +568,7 @@ async def open_sample_stream(
 
 
 async def sample_and_broadcast(
-
-    bus: _FeedsBus,  # noqa
+    bus: _FeedsBus,
     rt_shm: ShmArray,
     hist_shm: ShmArray,
     quote_stream: trio.abc.ReceiveChannel,
@@ -583,11 +588,33 @@ async def sample_and_broadcast(
 
     overruns = Counter()
 
+    # NOTE, only used for debugging live-data-feed issues, though
+    # this should be resolved more correctly in the future using the
+    # new typed-msgspec feats of `tractor`!
+    #
+    # XXX, a multiline nested `dict` formatter (since rn quote-msgs
+    # are just that).
+    # pfmt: Callable[[str], str] = mk_repr()
+
     # iterate stream delivered by broker
     async for quotes in quote_stream:
         # print(quotes)
 
-        # TODO: ``numba`` this!
+        # XXX WARNING XXX only enable for debugging bc ow can cost
+        # ALOT of perf with HF-feedz!!!
+        #
+        # log.info(
+        #     'Rx live quotes:\n'
+        #     f'{pfmt(quotes)}'
+        # )
+
+        # TODO,
+        # -[ ] `numba` or `cython`-nize this loop possibly?
+        #  |_alternatively could we do it in rust somehow by upacking
+        #    arrow msgs instead of using `msgspec`?
+        # -[ ] use `msgspec.Struct` support in new typed-msging from
+        #     `tractor` to ensure only allowed msgs are transmitted?
+        #
         for broker_symbol, quote in quotes.items():
             # TODO: in theory you can send the IPC msg *before* writing
             # to the sharedmem array to decrease latency, however, that
@@ -660,6 +687,21 @@ async def sample_and_broadcast(
             sub_key: str = broker_symbol.lower()
             subs: set[Sub] = bus.get_subs(sub_key)
 
+            # TODO, figure out how to make this useful whilst
+            # incoporating feed "pausing" ..
+            #
+            # if not subs:
+            #     all_bs_fqmes: list[str] = list(
+            #         bus._subscribers.keys()
+            #     )
+            #     log.warning(
+            #         f'No subscribers for {brokername!r} live-quote ??\n'
+            #         f'broker_symbol: {broker_symbol}\n\n'
+
+            #         f'Maybe the backend-sys symbol does not match one of,\n'
+            #         f'{pfmt(all_bs_fqmes)}\n'
+            #     )
+
             # NOTE: by default the broker backend doesn't append
             # it's own "name" into the fqme schema (but maybe it
             # should?) so we have to manually generate the correct
@@ -729,18 +771,14 @@ async def sample_and_broadcast(
                         if lags > 10:
                             await tractor.pause()
 
-                except (
-                    trio.BrokenResourceError,
-                    trio.ClosedResourceError,
-                    trio.EndOfChannel,
-                ):
+                except Sampler.bcast_errors as ipc_err:
                     ctx: Context = ipc._ctx
                     chan: Channel = ctx.chan
                     if ctx:
                         log.warning(
-                            'Dropped `brokerd`-quotes-feed connection:\n'
-                            f'{broker_symbol}:'
-                            f'{ctx.cid}@{chan.uid}'
+                            f'Dropped `brokerd`-feed for {broker_symbol!r} due to,\n'
+                            f'x>) {ctx.cid}@{chan.uid}'
+                            f'|_{ipc_err!r}\n\n'
                         )
                     if sub.throttle_rate:
                         assert ipc._closed
@@ -757,12 +795,11 @@ async def sample_and_broadcast(
 
 
 async def uniform_rate_send(
-
     rate: float,
     quote_stream: trio.abc.ReceiveChannel,
     stream: MsgStream,
 
-    task_status: TaskStatus = trio.TASK_STATUS_IGNORED,
+    task_status: TaskStatus[None] = trio.TASK_STATUS_IGNORED,
 
 ) -> None:
     '''
@@ -780,13 +817,16 @@ async def uniform_rate_send(
     https://gist.github.com/njsmith/7ea44ec07e901cb78ebe1dd8dd846cb9
 
     '''
-    # TODO: compute the approx overhead latency per cycle
-    left_to_sleep = throttle_period = 1/rate - 0.000616
+    # ?TODO? dynamically compute the **actual** approx overhead latency per cycle
+    # instead of this magic # bidinezz?
+    throttle_period: float = 1/rate - 0.000616
+    left_to_sleep: float = throttle_period
 
     # send cycle state
+    first_quote: dict|None
     first_quote = last_quote = None
-    last_send = time.time()
-    diff = 0
+    last_send: float = time.time()
+    diff: float = 0
 
     task_status.started()
     ticks_by_type: dict[
@@ -797,22 +837,28 @@ async def uniform_rate_send(
     clear_types = _tick_groups['clears']
 
     while True:
-
         # compute the remaining time to sleep for this throttled cycle
-        left_to_sleep = throttle_period - diff
+        left_to_sleep: float = throttle_period - diff
 
         if left_to_sleep > 0:
+            cs: trio.CancelScope
             with trio.move_on_after(left_to_sleep) as cs:
+                sym: str
+                last_quote: dict
                 try:
                     sym, last_quote = await quote_stream.receive()
                 except trio.EndOfChannel:
-                    log.exception(f"feed for {stream} ended?")
+                    log.exception(
+                        f'Live stream for feed for ended?\n'
+                        f'<=c\n'
+                        f'  |_[{stream!r}\n'
+                    )
                     break
 
-                diff = time.time() - last_send
+                diff: float = time.time() - last_send
 
                 if not first_quote:
-                    first_quote = last_quote
+                    first_quote: float = last_quote
                     # first_quote['tbt'] = ticks_by_type
 
                 if (throttle_period - diff) > 0:
@@ -873,11 +919,12 @@ async def uniform_rate_send(
         # TODO: now if only we could sync this to the display
         # rate timing exactly lul
         try:
-            await stream.send({sym: first_quote})
+            await stream.send({
+                sym: first_quote
+            })
         except tractor.RemoteActorError as rme:
             if rme.type is not tractor._exceptions.StreamOverrun:
                 raise
-
             ctx = stream._ctx
             chan = ctx.chan
             log.warning(
@@ -885,20 +932,28 @@ async def uniform_rate_send(
                 f'{sym}:{ctx.cid}@{chan.uid}'
             )
 
+        # NOTE: any of these can be raised by `tractor`'s IPC
+        # transport-layer and we want to be highly resilient
+        # to consumers which crash or lose network connection.
+        # I.e. we **DO NOT** want to crash and propagate up to
+        # ``pikerd`` these kinds of errors!
         except (
-            # NOTE: any of these can be raised by ``tractor``'s IPC
-            # transport-layer and we want to be highly resilient
-            # to consumers which crash or lose network connection.
-            # I.e. we **DO NOT** want to crash and propagate up to
-            # ``pikerd`` these kinds of errors!
-            trio.ClosedResourceError,
-            trio.BrokenResourceError,
             ConnectionResetError,
-            trio.EndOfChannel,
-        ):
-            # if the feed consumer goes down then drop
-            # out of this rate limiter
-            log.warning(f'{stream} closed')
+        ) + Sampler.bcast_errors as ipc_err:
+            match ipc_err:
+                case trio.EndOfChannel():
+                    log.info(
+                        f'{stream} terminated by peer,\n'
+                        f'{ipc_err!r}'
+                    )
+                case _:
+                    # if the feed consumer goes down then drop
+                    # out of this rate limiter
+                    log.warning(
+                        f'{stream} closed due to,\n'
+                        f'{ipc_err!r}'
+                    )
+
             await stream.aclose()
             return
 

piker/log.py

@@ -18,8 +18,8 @@
 Log like a forester!
 """
 import logging
-import reprlib
 import json
+import reprlib
 from typing import (
     Callable,
 )
@@ -90,6 +90,8 @@ def colorize_json(
     )
 
 
+# TODO, eventually defer to the version in `modden` once
+# it becomes a dep!
 def mk_repr(
     **repr_kws,
 ) -> Callable[[str], str]:

piker/storage/__init__.py

@@ -138,16 +138,6 @@ class StorageClient(
     ) -> None:
         ...
 
-    async def write_oi(
-        self,
-        fqme: str,
-        oi: np.ndarray,
-        append_and_duplicate: bool = True,
-        limit: int = int(800e3),
-
-    ) -> None:
-        ...
-
 
 class TimeseriesNotFound(Exception):
     '''

piker/storage/nativedb.py

@@ -111,24 +111,6 @@ def mk_ohlcv_shm_keyed_filepath(
     return path
 
 
-def mk_oi_shm_keyed_filepath(
-    fqme: str,
-    period: float | int,
-    datadir: Path,
-
-) -> Path:
-
-    if period < 1.:
-        raise ValueError('Sample period should be >= 1.!?')
-
-    path: Path = (
-        datadir
-        /
-        f'{fqme}.oi{int(period)}s.parquet'
-    )
-    return path
-
-
 def unpack_fqme_from_parquet_filepath(path: Path) -> str:
 
     filename: str = str(path.name)
@@ -190,11 +172,7 @@ class NativeStorageClient:
 
             key: str = path.name.rstrip('.parquet')
             fqme, _, descr = key.rpartition('.')
-            if 'ohlcv' in descr: 
-                prefix, _, suffix = descr.partition('ohlcv')
-            elif 'oi' in descr:
-                prefix, _, suffix = descr.partition('oi')
-
+            prefix, _, suffix = descr.partition('ohlcv')
             period: int = int(suffix.strip('s'))
 
             # cache description data
@@ -391,61 +369,6 @@ class NativeStorageClient:
             timeframe,
         )
 
-    def _write_oi(
-        self,
-        fqme: str,
-        oi: np.ndarray,
-
-    ) -> Path:
-        '''
-        Sync version of the public interface meth, since we don't
-        currently actually need or support an async impl.
-
-        '''
-        path: Path = mk_oi_shm_keyed_filepath(
-            fqme=fqme,
-            period=1,
-            datadir=self._datadir,
-        )
-        if isinstance(oi, np.ndarray):
-            new_df: pl.DataFrame = tsp.np2pl(oi)
-        else:
-            new_df = oi
-
-        if path.exists():
-            old_df = pl.read_parquet(path)
-            df = pl.concat([old_df, new_df])
-        else:
-            df = new_df
-
-        start = time.time()
-        df.write_parquet(path)
-        delay: float = round(
-            time.time() - start,
-            ndigits=6,
-        )
-        log.info(
-            f'parquet write took {delay} secs\n'
-            f'file path: {path}'
-        )
-        return path
-
-    async def write_oi(
-        self,
-        fqme: str,
-        oi: np.ndarray,
-
-    ) -> Path:
-        '''
-        Write input oi time series for fqme and sampling period
-        to (local) disk.
-
-        '''
-        return self._write_oi(
-            fqme,
-            oi,
-        )
-
     async def delete_ts(
         self,
         key: str,

pyproject.toml

@@ -139,6 +139,7 @@ pyqtgraph = { git = "https://github.com/pikers/pyqtgraph.git" }
 asyncvnc = { git = "https://github.com/pikers/asyncvnc.git", branch = "main" }
 tomlkit = { git = "https://github.com/pikers/tomlkit.git", branch ="piker_pin" }
 
+# XXX, since we're like, always hacking new shite atm.. Bp
+tractor = { git = "https://pikers.dev/goodboy/tractor", branch = "piker_pin" }
 # tractor = { git = "https://pikers.dev/goodboy/tractor", branch = "main" }
-# XXX, since i'm hacking 3.13 support atm..
-tractor = { path = "../tractor", editable = true }
+# tractor = { path = "../tractor", editable = true }