Merge pull request 'how_to_show_ur_pp: fixes for end-2-end order/position display'

Reviewed-on: https://www.pikers.dev/pikers/piker/pulls/60

README.rst

@@ -88,22 +88,57 @@ a sane install with `uv`
 ************************
 bc why install with `python` when you can faster with `rust` ::
 
-    uv lock
+    uv sync
+
+    # ^ astral's docs,
+    # https://docs.astral.sh/uv/concepts/projects/sync/
+
+include all GUIs (ex. for charting)::
+
+    uv sync --extra uis
+
+AND with all our hacking tools and WIP integrations::
+
+    uv sync --dev --all-extras 
 
 
-hacky install on nixos
+Ensure you can run the root-daemon::
-**********************
+
+    uv run pikerd [-l info --pdb]
+
+
+install on nix(os)
+******************
 ``NixOS`` is our core devs' distro of choice for which we offer
-a stringently defined development shell envoirment that can be loaded with::
+a stringently defined development shell envoirment that can currently
+be applied in one of 2 ways::
 
+    # ONLY if running on X11
     nix-shell default.nix
 
+Or if you prefer flakes style and a modern DE::
+
+    # ONLY if also running on Wayland
+    nix develop  # for default bash
+    nix develop -c uv run xonsh  # for @goodboy's preferred sh B)
+
 
 start a chart
 *************
 run a realtime OHLCV chart stand-alone::
 
-    piker -l info chart btcusdt.spot.binance xmrusdt.spot.kraken
+    [uv run] piker -l info chart btcusdt.spot.binance xmrusdt.spot.kraken
+
+    # ^^^ iff you haven't activated the py-env,
+    # - https://docs.astral.sh/uv/concepts/projects/run/
+    #
+    # in order to create an explicit virt-env see,
+    # - https://docs.astral.sh/uv/concepts/projects/layout/#the-project-environment
+    # - https://docs.astral.sh/uv/pip/environments/
+    #
+    # use $UV_PROJECT_ENVIRONMENT to select any non-`.venv/`
+    # as the venv sudir in the repo's root.
+    # - https://docs.astral.sh/uv/reference/environment/#uv_project_environment
 
 this runs a chart UI (with 1m sampled OHLCV) and shows 2 spot markets from 2 diff cexes
 overlayed on the same graph. Use of `piker` without first starting

config/brokers.toml

@@ -1,6 +1,5 @@
-################
 # ---- CEXY ----
-################
+
 [binance]
 accounts.paper = 'paper'
 
@@ -13,28 +12,41 @@ accounts.spot = 'spot'
 spot.use_testnet = false
 spot.api_key = ''
 spot.api_secret = ''
+# ------ binance ------
 
 
 [deribit]
+# std assets
 key_id = ''
 key_secret = ''
+# options
+accounts.option = 'option'
+option.use_testnet = false
+option.key_id = ''
+option.key_secret = ''
+# aux logging from `cryptofeed`
+option.log.filename = 'cryptofeed.log'
+option.log.level = 'DEBUG'
+option.log.disabled = true
+# ------ deribit ------
 
 
 [kraken]
 key_descr = ''
 api_key = ''
 secret = ''
+# ------ kraken ------
 
 
 [kucoin]
 key_id = ''
 key_secret = ''
 key_passphrase = ''
+# ------ kucoin ------
 
 
-################
 # -- BROKERZ ---
-################
+
 [questrade]
 refresh_token = ''
 access_token = ''
@@ -42,44 +54,55 @@ api_server = 'https://api06.iq.questrade.com/'
 expires_in = 1800
 token_type = 'Bearer'
 expires_at = 1616095326.355846
+# ------ questrade ------
 
 
 [ib]
+# define the (set of) host-port socketaddrs that
+# brokerd.ib will scan to connect to an API endpoint
+# (ib-gw or ib-tws listening instances)
 hosts = [
     '127.0.0.1',
 ]
-# XXX: the order in which ports will be scanned
-# (by the `brokerd` daemon-actor)
-# is determined # by the line order here.
-# TODO: when we eventually spawn gateways in our
-# container, we can just dynamically allocate these
-# using IBC.
 ports = [
     4002,  # gw
     7497,  # tws
 ]
 
-# XXX: for a paper account the flex web query service
+# When API endpoints are being scanned durin startup, the order
-# is not supported so you have to manually download
+# of user-defined-account "names" (as defined below) here
-# and XML report and put it in a location that can be
+# determines which py-client connection is given priority to be
-# accessed by the ``brokerd.ib`` backend code for parsing.
+# used for data-feed-requests by according to whichever client
-flex_token = ''
+# connected to an API endpoing which reported the equivalent
-flex_trades_query_id = ''  # live account
+# account number for that name.
-
-# when clients are being scanned this determines
-# which clients are preferred to be used for data
-# feeds based on the order of account names, if
-# detected as active on an API client.
 prefer_data_account = [
     'paper',
     'margin',
     'ira',
 ]
 
+# For long-term trades txn (transaction) history
+# processing (i.e your txn ledger with IB) you can
+# (automatically for live accounts) query the FLEX
+# report system for past history.
+#
+# (For paper accounts the web query service
+# is not supported so you have to manually download
+# an XML report and put it in a location that can be
+# accessed by our `brokerd.ib` backend code for parsing).
+#
+flex_token = ''
+flex_trades_query_id = ''  # live account
+
+# define "aliases" (names) for each account number
+# such that the names can be reffed and logged throughout
+# `piker.accounting` subsys and more easily
+# referred to  by the user.
+#
+# These keys will be the set exposed through the order-mode
+# account-selection UI so that numbers are never shown.
 [ib.accounts]
-# the order in which accounts will be selectable
+paper = 'DU0000000'  # <- literal account #
-# in the order mode UI (if found via clients during
+margin = 'U0000000'
-# API-app scanning)when a new symbol is loaded.
+ira = 'U0000000'
-paper = 'XX0000000'
+# ------ ib ------
-margin = 'X0000000'
-ira = 'X0000000'

config/conf.toml

@@ -1,7 +1,9 @@
 [network]
-tsdb.backend = 'marketstore'
+pikerd = [
-tsdb.host = 'localhost'
+  '/ipv4/127.0.0.1/tcp/6116',  # std localhost daemon-actor tree
-tsdb.grpc_port = 5995
+  # '/uds/6116',  # TODO std uds socket file
+]
+
 
 [ui]
 # set custom font + size which will scale entire UI

default.nix

@@ -11,11 +11,12 @@ let
   libxkbcommonStorePath = lib.getLib libxkbcommon;
   xcbutilcursorStorePath = lib.getLib xcb-util-cursor;
 
-  qtpyStorePath = lib.getLib python312Packages.qtpy;
+  pypkgs = python313Packages;
-  pyqt6StorePath = lib.getLib python312Packages.pyqt6;
+  qtpyStorePath = lib.getLib pypkgs.qtpy;
-  pyqt6SipStorePath = lib.getLib python312Packages.pyqt6-sip;
+  pyqt6StorePath = lib.getLib pypkgs.pyqt6;
-  rapidfuzzStorePath = lib.getLib python312Packages.rapidfuzz;
+  pyqt6SipStorePath = lib.getLib pypkgs.pyqt6-sip;
-  qdarkstyleStorePath = lib.getLib python312Packages.qdarkstyle;
+  rapidfuzzStorePath = lib.getLib pypkgs.rapidfuzz;
+  qdarkstyleStorePath = lib.getLib pypkgs.qdarkstyle;
 
   xorgLibX11StorePath = lib.getLib xorg.libX11;
   xorgLibxcbStorePath = lib.getLib xorg.libxcb;
@@ -51,12 +52,12 @@ stdenv.mkDerivation {
     xorg.xcbutilrenderutil
 
     # Python requirements.
-    python312Full
+    python313
-    python312Packages.uv
+    uv
-    python312Packages.qdarkstyle
+    pypkgs.qdarkstyle
-    python312Packages.rapidfuzz
+    pypkgs.rapidfuzz
-    python312Packages.pyqt6
+    pypkgs.pyqt6
-    python312Packages.qtpy
+    pypkgs.qtpy
   ];
   src = null;
   shellHook = ''
@@ -113,11 +114,11 @@ stdenv.mkDerivation {
 
     export LD_LIBRARY_PATH
 
-    RPDFUZZ_PATH="${rapidfuzzStorePath}/lib/python3.12/site-packages"
+    RPDFUZZ_PATH="${rapidfuzzStorePath}/lib/python3.13/site-packages"
-    QDRKSTYLE_PATH="${qdarkstyleStorePath}/lib/python3.12/site-packages"
+    QDRKSTYLE_PATH="${qdarkstyleStorePath}/lib/python3.13/site-packages"
-    QTPY_PATH="${qtpyStorePath}/lib/python3.12/site-packages"
+    QTPY_PATH="${qtpyStorePath}/lib/python3.13/site-packages"
-    PYQT6_PATH="${pyqt6StorePath}/lib/python3.12/site-packages"
+    PYQT6_PATH="${pyqt6StorePath}/lib/python3.13/site-packages"
-    PYQT6_SIP_PATH="${pyqt6SipStorePath}/lib/python3.12/site-packages"
+    PYQT6_SIP_PATH="${pyqt6SipStorePath}/lib/python3.13/site-packages"
 
     PATCH="$PATCH:$RPDFUZZ_PATH"
     PATCH="$PATCH:$QDRKSTYLE_PATH"
@@ -127,8 +128,8 @@ stdenv.mkDerivation {
 
     export PATCH
 
-    # Install deps
+    # install all dev and extras
-    uv lock
+    uv sync --dev --all-extras
 
   '';
 }

dockering/ib/README.rst

@@ -1,30 +1,138 @@
 running ``ib`` gateway in ``docker``
 ------------------------------------
-We have a config based on the (now defunct)
+We have a config based on a well maintained community
-image from "waytrade":
+image from `@gnzsnz`:
 
-https://github.com/waytrade/ib-gateway-docker
+https://github.com/gnzsnz/ib-gateway-docker
 
-To startup this image with our custom settings
+
-simply run the command::
+To startup this image simply run the command::
 
     docker compose up
 
-And you should have the following socket-available services:
+(For further usage^ see the official `docker-compose`_ docs)
 
-- ``x11vnc1@127.0.0.1:3003``
-- ``ib-gw@127.0.0.1:4002``
 
-You can attach to the container via a VNC client
+And you should have the following socket-available services by
-without password auth.
+default:
 
-SECURITY STUFF!?!?!
+- ``x11vnc1 @ 127.0.0.1:5900``
--------------------
+- ``ib-gw @ 127.0.0.1:4002``
-Though "``ib``" claims they host filter connections outside
+
-localhost (aka ``127.0.0.1``) it's probably better if you filter
+You can now attach to the container via a VNC client with password-auth;
-the socket at the OS level using a stateless firewall rule::
+here is an example using ``vncclient`` on ``linux``::
+
+    vncviewer localhost:5900
+
+now enter the pw (password) you set via an (see second code blob)
+`.env file`_ or pw-file according to the `credentials section`_.
+
+If you want to change away from their default config see the example
+`docker-compose.yml`-config issue and config-section of the readme,
+
+  - https://github.com/gnzsnz/ib-gateway-docker?tab=readme-ov-file#configuration
+  - https://github.com/gnzsnz/ib-gateway-docker/discussions/103
+
+.. _.env file: https://github.com/gnzsnz/ib-gateway-docker?tab=readme-ov-file#how-to-use-it
+.. _docker-compose: https://docs.docker.com/compose/
+.. _credentials section: https://github.com/gnzsnz/ib-gateway-docker?tab=readme-ov-file#credentials
+
+
+Connecting to the API from `piker`
+---------------------------------
+In order to expose the container's API endpoint to the
+`brokerd/datad/ib` actor, we need to add a section to the user's
+`brokers.toml` config (note the below is similar to the repo-shipped
+template file),
+
+.. code:: toml
+
+    [ib]
+    # define the (set of) host-port socketaddrs that
+    # brokerd.ib will scan to connect to an API endpoint
+    # (ib-gw or ib-tws listening instances)
+    hosts = [
+        '127.0.0.1',
+    ]
+    ports = [
+        4002,  # gw
+        7497,  # tws
+    ]
+
+    # When API endpoints are being scanned durin startup, the order
+    # of user-defined-account "names" (as defined below) here
+    # determines which py-client connection is given priority to be
+    # used for data-feed-requests by according to whichever client
+    # connected to an API endpoing which reported the equivalent
+    # account number for that name.
+    prefer_data_account = [
+        'paper',
+        'margin',
+        'ira',
+    ]
+
+    # define "aliases" (names) for each account number
+    # such that the names can be reffed and logged throughout
+    # `piker.accounting` subsys and more easily
+    # referred to  by the user.
+    #
+    # These keys will be the set exposed through the order-mode
+    # account-selection UI so that numbers are never shown.
+    [ib.accounts]
+    paper = 'XX0000000'
+    margin = 'X0000000'
+    ira = 'X0000000'
+
+
+the broker daemon can also connect to the container's VNC server for
+added functionalies including,
+
+- viewing the API endpoint program's GUI for manual interventions,
+- workarounds for historical data throttling using hotkey hacks,
+
+Add a further section to `brokers.toml` which maps each API-ep's
+port to a table of VNC server connection info like,
+
+.. code:: toml
+
+    [ib.vnc_addrs]
+    4002 = {host = 'localhost', port = 5900, pw = 'doggy'}
+
+The `pw = 'doggy'` here ^ should the same value as the particular
+container instances `.env` file setting (when it was run),
+
+.. code:: ini
+
+    VNC_SERVER_PASSWORD='doggy'
+
+
+IF you also want to run ``TWS``
+-------------------------------
+You can also run it containerized,
+
+https://github.com/gnzsnz/ib-gateway-docker?tab=readme-ov-file#using-tws
+
+
+SECURITY stuff (advanced, only if you're paranoid)
+--------------------------------------------------
+First and foremost if doing a "distributed" container setup where you
+run the ``ib-gw`` docker container and your connecting API client
+(likely ``ib_async`` from python) on **different hosts** be sure to
+read the `security considerations`_ section!
+
+And for a further (somewhat paranoid) perspective from
+a long-time-ago serious devops eng..
+
+Though "``ib``" claims they filter remote host connections outside
+``localhost`` (aka ``127.0.0.1`` on ipv4) it's prolly justified if
+you'd like to filter the socket at the *OS level* using a stateless
+firewall rule::
 
     ip rule add not unicast iif lo to 0.0.0.0/0 dport 4002
 
-We will soon have this baked into our own custom image but for
+
-now you'll have to do it urself dawgy.
+We will soon have this either baked into our own custom derivative
+image (or patched into the current upstream one after further testin)
+but for now you'll have to do it urself, diggity dawg.
+
+.. _security considerations: https://github.com/gnzsnz/ib-gateway-docker?tab=readme-ov-file#security-considerations

dockering/ib/docker-compose.yml

@@ -1,10 +1,15 @@
-# rework from the original @
+# a community maintained IB API container!
-# https://github.com/waytrade/ib-gateway-docker/blob/master/docker-compose.yml
+#
-version: "3.5"
+# https://github.com/gnzsnz/ib-gateway-docker
-
+#
+# For piker we (currently) include some minor deviations
+# for some config files in the `volumes` section.
+#
+# See full configuration settings @
+# - https://github.com/gnzsnz/ib-gateway-docker?tab=readme-ov-file#configuration
+# - https://github.com/gnzsnz/ib-gateway-docker/discussions/103
 
 services:
-
   ib_gw_paper:
 
     # apparently java is a mega cukc:
@@ -50,16 +55,22 @@ services:
         target: /root/scripts/run_x11_vnc.sh
         read_only: true
 
-    # NOTE:to fill these out, define an `.env` file in the same dir as
+    # NOTE: an alt method to fill these out is to
-    # this compose file which looks something like:
+    # define an `.env` file in the same dir as
-    # TWS_USERID='myuser'
+    # this compose file.
-    # TWS_PASSWORD='guest'
     environment:
       TWS_USERID: ${TWS_USERID}
+      # TWS_USERID: 'myuser'
       TWS_PASSWORD: ${TWS_PASSWORD}
-      TRADING_MODE: 'paper'
+      # TWS_PASSWORD: 'guest'
-      VNC_SERVER_PASSWORD: 'doggy'
+      TRADING_MODE: ${TRADING_MODE}
-      VNC_SERVER_PORT: '3003'
+      # TRADING_MODE: 'paper'
+      VNC_SERVER_PASSWORD: ${VNC_SERVER_PASSWORD}
+      # VNC_SERVER_PASSWORD: 'doggy'
+
+      # TODO, see if we can get this supported like it
+      # was on the old `waytrade` image?
+      # VNC_SERVER_PORT: '3003'
 
     # ports:
     #   - target: 4002
@@ -76,6 +87,9 @@ services:
       # - "127.0.0.1:4002:4002"
       # - "127.0.0.1:5900:5900"
 
+  # TODO, a masked but working example of dual paper + live
+  # ib-gw instances running in a single app run!
+  #
   # ib_gw_live:
   #   image: waytrade/ib-gateway:1012.2i
   #   restart: no

examples/basic_order_bot.py

@@ -121,6 +121,7 @@ async def bot_main():
             # tick_throttle=10,
         ) as feed,
 
+        tractor.trionics.collapse_eg(),
         trio.open_nursery() as tn,
     ):
         assert accounts

flake.lock

@@ -1,135 +1,24 @@
 {
   "nodes": {
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1689068808,
-        "narHash": "sha256-6ixXo3wt24N/melDWjq70UuHQLxGV8jZvooRanIHXw0=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "919d646de7be200f3bf08cb76ae1f09402b6f9b4",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "flake-utils_2": {
-      "inputs": {
-        "systems": "systems_2"
-      },
-      "locked": {
-        "lastModified": 1689068808,
-        "narHash": "sha256-6ixXo3wt24N/melDWjq70UuHQLxGV8jZvooRanIHXw0=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "919d646de7be200f3bf08cb76ae1f09402b6f9b4",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nix-github-actions": {
-      "inputs": {
-        "nixpkgs": [
-          "poetry2nix",
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1688870561,
-        "narHash": "sha256-4UYkifnPEw1nAzqqPOTL2MvWtm3sNGw1UTYTalkTcGY=",
-        "owner": "nix-community",
-        "repo": "nix-github-actions",
-        "rev": "165b1650b753316aa7f1787f3005a8d2da0f5301",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "nix-github-actions",
-        "type": "github"
-      }
-    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1692174805,
+        "lastModified": 1765779637,
-        "narHash": "sha256-xmNPFDi/AUMIxwgOH/IVom55Dks34u1g7sFKKebxUm0=",
+        "narHash": "sha256-KJ2wa/BLSrTqDjbfyNx70ov/HdgNBCBBSQP3BIzKnv4=",
-        "owner": "NixOS",
+        "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "caac0eb6bdcad0b32cb2522e03e4002c8975c62e",
+        "rev": "1306659b587dc277866c7b69eb97e5f07864d8c4",
         "type": "github"
       },
       "original": {
-        "owner": "NixOS",
+        "owner": "nixos",
         "ref": "nixos-unstable",
         "repo": "nixpkgs",
         "type": "github"
       }
     },
-    "poetry2nix": {
-      "inputs": {
-        "flake-utils": "flake-utils_2",
-        "nix-github-actions": "nix-github-actions",
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1692048894,
-        "narHash": "sha256-cDw03rso2V4CDc3Mll0cHN+ztzysAvdI8pJ7ybbz714=",
-        "ref": "refs/heads/pyqt6",
-        "rev": "b059ad4c3051f45d6c912e17747aae37a9ec1544",
-        "revCount": 2276,
-        "type": "git",
-        "url": "file:///home/lord_fomo/repos/poetry2nix"
-      },
-      "original": {
-        "type": "git",
-        "url": "file:///home/lord_fomo/repos/poetry2nix"
-      }
-    },
     "root": {
       "inputs": {
-        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
-        "nixpkgs": "nixpkgs",
-        "poetry2nix": "poetry2nix"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    },
-    "systems_2": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
       }
     }
   },

flake.nix

@@ -1,180 +1,103 @@
-# NOTE: to convert to a poetry2nix env like this here are the
+# An "impure" template thx to `pyproject.nix`,
-# steps:
+# https://pyproject-nix.github.io/pyproject.nix/templates.html#impure
-# - install poetry in your system nix config
+# https://github.com/pyproject-nix/pyproject.nix/blob/master/templates/impure/flake.nix
-# - convert the repo to use poetry using `poetry init`:
-#   https://python-poetry.org/docs/basic-usage/#initialising-a-pre-existing-project
-# - then manually ensuring all deps are converted over:
-# - add this file to the repo and commit it
-# - 
-
-# GROKin tips:
-# - CLI eps are (ostensibly) added via an `entry_points.txt`:
-#   - https://packaging.python.org/en/latest/specifications/entry-points/#file-format
-#   - https://github.com/nix-community/poetry2nix/blob/master/editable.nix#L49
 {
-  description = "piker: trading gear for hackers (pkged with poetry2nix)";
+  description = "An impure `piker` overlay using `uv` with Nix(OS)";
 
-  inputs.flake-utils.url = "github:numtide/flake-utils";
+  inputs = {
-  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
-
-  # see https://github.com/nix-community/poetry2nix/tree/master#api
-  inputs.poetry2nix = {
-    # url = "github:nix-community/poetry2nix";
-    # url = "github:K900/poetry2nix/qt5-explicit-deps";
-    url = "/home/lord_fomo/repos/poetry2nix";
-
-    inputs.nixpkgs.follows = "nixpkgs";
   };
 
-  outputs = {
+  outputs =
-    self,
+    { nixpkgs, ... }:
-    nixpkgs,
+    let
-    flake-utils,
+      inherit (nixpkgs) lib;
-    poetry2nix,
+      forAllSystems = lib.genAttrs lib.systems.flakeExposed;
-  }:
+    in
-    # TODO: build cross-OS and use the `${system}` var thingy..
+    {
-    flake-utils.lib.eachDefaultSystem (system:
+      devShells = forAllSystems (
-      let
+        system:
-        # use PWD as sources
+        let
-        projectDir = ./.;
+          pkgs = nixpkgs.legacyPackages.${system};
-        pyproject = ./pyproject.toml;
-        poetrylock = ./poetry.lock;
 
-        # TODO: port to 3.11 and support both versions?
+          # do store-path extractions
-        python = "python3.10";
+          qt6baseStorePath = lib.getLib pkgs.qt6.qtbase;
+          # ?TODO? can remove below since manual linking not needed?
+          # qt6QtWaylandStorePath = lib.getLib pkgs.qt6.qtwayland;
 
-        # for more functions and examples.
+          # XXX NOTE XXX, for now we overlay specific pkgs via
-        # inherit
+          # a major-version-pinned-`cpython`
-        # (poetry2nix.legacyPackages.${system})
+          cpython = "python313";
-        # mkPoetryApplication;
+          pypkgs = pkgs."${cpython}Packages";
-        # pkgs = nixpkgs.legacyPackages.${system};
+        in
+        {
+          default = pkgs.mkShell {
 
-        pkgs = nixpkgs.legacyPackages.x86_64-linux;
+            packages = with pkgs; [
-        lib = pkgs.lib;
+              # XXX, ensure sh completions active!
-        p2npkgs = poetry2nix.legacyPackages.x86_64-linux;
+              bashInteractive
+              bash-completion
 
-        # define all pkg overrides per dep, see edgecases.md:
+              # dev utils
-        # https://github.com/nix-community/poetry2nix/blob/master/docs/edgecases.md
+              ruff
-        # TODO: add these into the json file:
+              pypkgs.ruff
-        # https://github.com/nix-community/poetry2nix/blob/master/overrides/build-systems.json
-        pypkgs-build-requirements = {
-          asyncvnc = [ "setuptools" ];
-          eventkit = [ "setuptools" ];
-          ib-insync = [ "setuptools" "flake8" ];
-          msgspec = [ "setuptools"];
-          pdbp = [ "setuptools" ];
-          pyqt6-sip = [ "setuptools" ];
-          tabcompleter = [ "setuptools" ];
-          tractor = [ "setuptools" ];
-          tricycle = [ "setuptools" ];
-          trio-typing = [ "setuptools" ];
-          trio-util = [ "setuptools" ];
-          xonsh = [ "setuptools" ];
-        };
 
-        # auto-generate override entries
+              qt6.qtwayland
-        p2n-overrides = p2npkgs.defaultPoetryOverrides.extend (self: super:
+              qt6.qtbase
-          builtins.mapAttrs (package: build-requirements:
-            (builtins.getAttr package super).overridePythonAttrs (old: {
-              buildInputs = (
-                old.buildInputs or [ ]
-              ) ++ (
-                builtins.map (
-                  pkg: if builtins.isString pkg then builtins.getAttr pkg super else pkg
-                  ) build-requirements
-              );
-            })
-          ) pypkgs-build-requirements
-        );
 
-        # override some ahead-of-time compiled extensions
+              uv
-        # to be built with their wheels.
+              python313  # ?TODO^ how to set from `cpython` above?
-        ahot_overrides = p2n-overrides.extend(
+              pypkgs.pyqt6
-          final: prev: {
+              pypkgs.pyqt6-sip
+              pypkgs.qtpy
+              pypkgs.qdarkstyle
+              pypkgs.rapidfuzz
+            ];
 
-            # llvmlite = prev.llvmlite.override {
+            shellHook = ''
-            #   preferWheel = false;
+              # unmask to debug **this** dev-shell-hook
-            # };
+              # set -e
 
-            # TODO: get this workin with p2n and nixpkgs..
+              # set qt-base/plugin path(s)
-            # pyqt6 = prev.pyqt6.override {
+              QTBASE_PATH="${qt6baseStorePath}/lib"
-            #   preferWheel = true;
+              QT_PLUGIN_PATH="${qt6baseStorePath}/lib/qt-6/plugins"
-            # };
+              QT_QPA_PLATFORM_PLUGIN_PATH="$QT_PLUGIN_PATH/platforms"
 
-            # NOTE: this DOESN'T work atm but after a fix
+              # link in Qt cc lib paths from <nixpkgs>
-            # to poetry2nix, it will and actually this line
+              LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$QTBASE_PATH"
-            # won't be needed - thanks @k900:
+              LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$QT_PLUGIN_PATH"
-            # https://github.com/nix-community/poetry2nix/pull/1257
+              LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$QT_QPA_PLATFORM_PLUGIN_PATH"
-            pyqt5 = prev.pyqt5.override {
-              # withWebkit = false;
-              preferWheel = true;
-            };
 
-            # see PR from @k900:
+              # link-in c++ stdlib for various AOT-ext-pkgs (numpy, etc.)
-            # https://github.com/nix-community/poetry2nix/pull/1257
+              LD_LIBRARY_PATH="${pkgs.stdenv.cc.cc.lib}/lib:$LD_LIBRARY_PATH"
-            # pyqt5-qt5 = prev.pyqt5-qt5.override {
-            #   withWebkit = false;
-            #   preferWheel = true;
-            # };
 
-            # TODO: patch in an override for polars to build
+              export LD_LIBRARY_PATH
-            # from src! See the details likely needed from
-            # the cryptography entry:
-            # https://github.com/nix-community/poetry2nix/blob/master/overrides/default.nix#L426-L435
-            polars = prev.polars.override {
-              preferWheel = true;
-            };
-          }
-      );
 
-      # WHY!? -> output-attrs that `nix develop` scans for:
+              # RUNTIME-SETTINGS
-      # https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-develop.html#flake-output-attributes
+              #
-      in
+              # ------ Qt ------
-      rec {
+              # XXX, unmask to debug qt .so linking/loading deats
-        packages = {
+              # export QT_DEBUG_PLUGINS=1
-          # piker = poetry2nix.legacyPackages.x86_64-linux.mkPoetryEditablePackage {
+              #
-          #   editablePackageSources = { piker = ./piker; };
+              # ALSO, for *modern linux* DEs,
+              # - maybe set wayland-mode (TODO, parametrtize this!)
+              #  * a chosen wayland-mode shell-integration
+              export QT_QPA_PLATFORM="wayland"
+              export QT_WAYLAND_SHELL_INTEGRATION="xdg-shell"
 
-          piker = p2npkgs.mkPoetryApplication {
+              # ------ uv ------
-            projectDir = projectDir;
+              # - always use the ./py313/ venv-subdir
+              export UV_PROJECT_ENVIRONMENT="py313"
+              # sync project-env with all extras
+              uv sync --dev --all-extras --no-group lint
 
-            # SEE ABOVE for auto-genned input set, override
+              # ------ TIPS ------
-            # buncha deps with extras.. like `setuptools` mostly.
+              # NOTE, to launch the py-venv installed `xonsh` (like @goodboy)
-            # TODO: maybe propose a patch to p2n to show that you
+              # run the `nix develop` cmd with,
-            # can even do this in the edgecases docs?
+              # >> nix develop -c uv run xonsh
-            overrides = ahot_overrides;
+            '';
-
-            # XXX: won't work on llvmlite..
-            # preferWheels = true;
           };
-        };
+        }
-
+      );
-        # devShells.default = pkgs.mkShell {
+    };
-        #   projectDir = projectDir;
-        #   python = "python3.10";
-        #   overrides = ahot_overrides;
-        #   inputsFrom = [ self.packages.x86_64-linux.piker ];
-        #   packages = packages;
-        #   # packages = [ poetry2nix.packages.${system}.poetry ];
-        # };
-
-        # TODO: grok the difference here..
-        # - avoid re-cloning git repos on every develop entry..
-        # - ideally allow hacking on the src code of some deps
-        #   (tractor, pyqtgraph, tomlkit, etc.) WITHOUT having to
-        #   re-install them every time a change is made.
-        # - boot a usable xonsh inside the poetry virtualenv when
-        #   defined via a custom entry point?
-        devShells.default = p2npkgs.mkPoetryEnv {
-        # env = p2npkgs.mkPoetryEnv {
-            projectDir = projectDir;
-            python = pkgs.python310;
-            overrides = ahot_overrides;
-            editablePackageSources = packages;
-              # piker = "./";
-              # tractor = "../tractor/";
-            # };  # wut?
-        };
-      }
-    );  # end of .outputs scope
 }

piker/accounting/__init__.py

@@ -33,7 +33,6 @@ from ._pos import (
     Account,
     load_account,
     load_account_from_ledger,
-    open_pps,
     open_account,
     Position,
 )
@@ -42,7 +41,6 @@ from ._mktinfo import (
     dec_digits,
     digits_to_dec,
     MktPair,
-    Symbol,
     unpack_fqme,
     _derivs as DerivTypes,
 )
@@ -60,7 +58,6 @@ __all__ = [
     'Asset',
     'MktPair',
     'Position',
-    'Symbol',
     'Transaction',
     'TransactionLedger',
     'dec_digits',
@@ -70,7 +67,6 @@ __all__ = [
     'load_account_from_ledger',
     'mk_allocator',
     'open_account',
-    'open_pps',
     'open_trade_ledger',
     'unpack_fqme',
     'DerivTypes',

piker/accounting/_ledger.py

@@ -40,7 +40,7 @@ import tomli_w  # for fast ledger writing
 
 from piker.types import Struct
 from piker import config
-from ..log import get_logger
+from piker.log import get_logger
 from .calc import (
     iter_by_dt,
 )
@@ -239,7 +239,9 @@ class TransactionLedger(UserDict):
 
         symcache: SymbologyCache = self._symcache
         towrite: dict[str, Any] = {}
-        for tid, txdict in self.tx_sort(self.data.copy()):
+        for tid, txdict in self.tx_sort(
+            self.data.copy()
+        ):
             # write blank-str expiry for non-expiring assets
             if (
                 'expiry' in txdict
@@ -377,7 +379,7 @@ def open_trade_ledger(
         account,
         dirpath=_fp,
     )
-    cpy = ledger_dict.copy()
+    cpy: dict = ledger_dict.copy()
 
     # XXX NOTE: if not provided presume we are being called from
     # sync code and need to maybe run `trio` to generate..
@@ -406,7 +408,13 @@ def open_trade_ledger(
         account=account,
         mod=mod,
         symcache=symcache,
-        tx_sort=getattr(mod, 'tx_sort', tx_sort),
+
+        # NOTE: allow backends to provide custom ledger sorting
+        tx_sort=getattr(
+            mod,
+            'tx_sort',
+            tx_sort,
+        ),
     )
     try:
         yield ledger

piker/accounting/_mktinfo.py

@@ -305,8 +305,8 @@ class MktPair(Struct, frozen=True):
     # config right?
     # src_type: AssetTypeName
 
-    # for derivs, info describing contract, egs.
+    # for derivs, info describing contract, egs. strike price, call
-    # strike price, call or put, swap type, exercise model, etc.
+    # or put, swap type, exercise model, etc.
     contract_info: list[str] | None = None
 
     # TODO: rename to sectype since all of these can
@@ -390,8 +390,8 @@ class MktPair(Struct, frozen=True):
         cls,
         fqme: str,
 
-        price_tick: float | str,
+        price_tick: float|str,
-        size_tick: float | str,
+        size_tick: float|str,
         bs_mktid: str,
 
         broker: str | None = None,
@@ -677,90 +677,3 @@ def unpack_fqme(
         # '.'.join([mkt_ep, venue]),
         suffix,
     )
-
-
-class Symbol(Struct):
-    '''
-    I guess this is some kinda container thing for dealing with
-    all the different meta-data formats from brokers?
-
-    '''
-    key: str
-
-    broker: str = ''
-    venue: str = ''
-
-    # precision descriptors for price and vlm
-    tick_size: Decimal = Decimal('0.01')
-    lot_tick_size: Decimal = Decimal('0.0')
-
-    suffix: str = ''
-    broker_info: dict[str, dict[str, Any]] = {}
-
-    @classmethod
-    def from_fqme(
-        cls,
-        fqsn: str,
-        info: dict[str, Any],
-
-    ) -> Symbol:
-        broker, mktep, venue, suffix = unpack_fqme(fqsn)
-        tick_size = info.get('price_tick_size', 0.01)
-        lot_size = info.get('lot_tick_size', 0.0)
-
-        return Symbol(
-            broker=broker,
-            key=mktep,
-            tick_size=tick_size,
-            lot_tick_size=lot_size,
-            venue=venue,
-            suffix=suffix,
-            broker_info={broker: info},
-        )
-
-    @property
-    def type_key(self) -> str:
-        return list(self.broker_info.values())[0]['asset_type']
-
-    @property
-    def tick_size_digits(self) -> int:
-        return float_digits(self.tick_size)
-
-    @property
-    def lot_size_digits(self) -> int:
-        return float_digits(self.lot_tick_size)
-
-    @property
-    def price_tick(self) -> Decimal:
-        return Decimal(str(self.tick_size))
-
-    @property
-    def size_tick(self) -> Decimal:
-        return Decimal(str(self.lot_tick_size))
-
-    @property
-    def broker(self) -> str:
-        return list(self.broker_info.keys())[0]
-
-    @property
-    def fqme(self) -> str:
-        return maybe_cons_tokens([
-            self.key,  # final "pair name" (eg. qqq[/usd], btcusdt)
-            self.venue,
-            self.suffix,  # includes expiry and other con info
-            self.broker,
-        ])
-
-    def quantize(
-        self,
-        size: float,
-    ) -> Decimal:
-        digits = float_digits(self.lot_tick_size)
-        return Decimal(size).quantize(
-            Decimal(f'1.{"0".ljust(digits, "0")}'),
-            rounding=ROUND_HALF_EVEN
-        )
-
-    # NOTE: when cast to `str` return fqme
-    def __str__(self) -> str:
-        return self.fqme

piker/accounting/_pos.py

@@ -30,7 +30,8 @@ from types import ModuleType
 from typing import (
     Any,
     Iterator,
-    Generator
+    Generator,
+    TYPE_CHECKING,
 )
 
 import pendulum
@@ -59,8 +60,10 @@ from ..clearing._messages import (
     BrokerdPosition,
 )
 from piker.types import Struct
-from piker.data._symcache import SymbologyCache
+from piker.log import get_logger
-from ..log import get_logger
+
+if TYPE_CHECKING:
+    from piker.data._symcache import SymbologyCache
 
 log = get_logger(__name__)
 
@@ -353,17 +356,20 @@ class Position(Struct):
     ) -> bool:
         '''
         Update clearing table by calculating the rolling ppu and
-        (accumulative) size in both the clears entry and local
+        (accumulative) size in both the clears entry and local attrs
-        attrs state.
+        state.
 
         Inserts are always done in datetime sorted order.
 
         '''
-        # added: bool = False
         tid: str = t.tid
         if tid in self._events:
-            log.warning(f'{t} is already added?!')
+            log.debug(
-            # return added
+                f'Txn is already added?\n'
+                f'\n'
+                f'{t}\n'
+            )
+            return False
 
         # TODO: apparently this IS possible with a dict but not
         # common and probably not that beneficial unless we're also
@@ -444,6 +450,12 @@ class Position(Struct):
     # def suggest_split(self) -> float:
     #     ...
 
+    # ?TODO, for sending rendered state over the wire?
+    # def summary(self) -> PositionSummary:
+        # do minimal conversion to a subset of fields
+        # currently defined in `.clearing._messages.BrokerdPosition`
+
+
 
 class Account(Struct):
     '''
@@ -487,12 +499,23 @@ class Account(Struct):
 
     def update_from_ledger(
         self,
-        ledger: TransactionLedger | dict[str, Transaction],
+        ledger: TransactionLedger|dict[str, Transaction],
         cost_scalar: float = 2,
-        symcache: SymbologyCache | None = None,
+        symcache: SymbologyCache|None = None,
 
         _mktmap_table: dict[str, MktPair] | None = None,
 
+        only_require: list[str]|True = True,
+        # ^list of fqmes that are "required" to be processed from
+        # this ledger pass; we often don't care about others and
+        # definitely shouldn't always error in such cases.
+        # (eg. broker backend loaded that doesn't yet supsport the
+        # symcache but also, inside the paper engine we don't ad-hoc
+        # request `get_mkt_info()` for every symbol in the ledger,
+        # only the one for which we're simulating against).
+        # TODO, not sure if there's a better soln for this, ideally
+        # all backends get symcache support afap i guess..
+
     ) -> dict[str, Position]:
         '''
         Update the internal `.pps[str, Position]` table from input
@@ -535,11 +558,32 @@ class Account(Struct):
                 if _mktmap_table is None:
                     raise
 
+                required: bool = (
+                    only_require is True
+                    or (
+                        only_require is not True
+                        and
+                        fqme in only_require
+                    )
+                )
                 # XXX: caller is allowed to provide a fallback
                 # mktmap table for the case where a new position is
                 # being added and the preloaded symcache didn't
                 # have this entry prior (eg. with frickin IB..)
-                mkt = _mktmap_table[fqme]
+                if (
+                    not (mkt := _mktmap_table.get(fqme))
+                    and
+                    required
+                ):
+                    raise
+
+                elif not required:
+                    continue
+
+                else:
+                    # should be an entry retreived somewhere
+                    assert mkt
+
 
             if not (pos := pps.get(bs_mktid)):
 
@@ -656,7 +700,7 @@ class Account(Struct):
     def write_config(self) -> None:
         '''
         Write the current account state to the user's account TOML file, normally
-        something like ``pps.toml``.
+        something like `pps.toml`.
 
         '''
         # TODO: show diff output?
@@ -696,7 +740,7 @@ class Account(Struct):
                     else:
                         # TODO: we reallly need a diff set of
                         # loglevels/colors per subsys.
-                        log.warning(
+                        log.debug(
                             f'Recent position for {fqme} was closed!'
                         )
 
@@ -710,7 +754,7 @@ class Account(Struct):
         # XXX WTF: if we use a tomlkit.Integer here we get this
         # super weird --1 thing going on for cumsize!?1!
         # NOTE: the fix was to always float() the size value loaded
-        # in open_pps() below!
+        # in open_account() below!
         config.write(
             config=self.conf,
             path=self.conf_path,
@@ -894,7 +938,6 @@ def open_account(
             clears_table['dt'] = dt
             trans.append(Transaction(
                 fqme=bs_mktid,
-                # sym=mkt,
                 bs_mktid=bs_mktid,
                 tid=tid,
                 # XXX: not sure why sometimes these are loaded as
@@ -917,11 +960,22 @@ def open_account(
         ):
             expiry: pendulum.DateTime = pendulum.parse(expiry)
 
-        pp = pp_objs[bs_mktid] = Position(
+        # !XXX, should never be duplicates over
-            mkt,
+        # a backend-(broker)-system's unique market-IDs!
-            split_ratio=split_ratio,
+        if pos := pp_objs.get(bs_mktid):
-            bs_mktid=bs_mktid,
+            if mkt != pos.mkt:
-        )
+                log.warning(
+                    f'Duplicated position but diff `MktPair.fqme` ??\n'
+                    f'bs_mktid: {bs_mktid!r}\n'
+                    f'pos.mkt: {pos.mkt}\n'
+                    f'mkt: {mkt}\n'
+                )
+        else:
+            pos = pp_objs[bs_mktid] = Position(
+                mkt,
+                split_ratio=split_ratio,
+                bs_mktid=bs_mktid,
+            )
 
         # XXX: super critical, we need to be sure to include
         # all pps.toml clears to avoid reusing clears that were
@@ -929,8 +983,13 @@ def open_account(
         # state, since today's records may have already been
         # processed!
         for t in trans:
-            pp.add_clear(t)
+            added: bool = pos.add_clear(t)
-
+            if not added:
+                log.warning(
+                    f'Txn already recorded in pp ??\n'
+                    f'\n'
+                    f'{t}\n'
+                )
     try:
         yield acnt
     finally:
@@ -938,20 +997,6 @@ def open_account(
             acnt.write_config()
 
 
-# TODO: drop the old name and THIS!
-@cm
-def open_pps(
-    *args,
-    **kwargs,
-) -> Generator[Account, None, None]:
-    log.warning(
-        '`open_pps()` is now deprecated!\n'
-        'Please use `with open_account() as cnt:`'
-    )
-    with open_account(*args, **kwargs) as acnt:
-        yield acnt
-
-
 def load_account_from_ledger(
 
     brokername: str,

piker/accounting/calc.py

@@ -22,7 +22,9 @@ you know when you're losing money (if possible) XD
 from __future__ import annotations
 from collections.abc import ValuesView
 from contextlib import contextmanager as cm
+from functools import partial
 from math import copysign
+from pprint import pformat
 from typing import (
     Any,
     Callable,
@@ -30,6 +32,7 @@ from typing import (
     TYPE_CHECKING,
 )
 
+from tractor.devx import maybe_open_crash_handler
 import polars as pl
 from pendulum import (
     DateTime,
@@ -37,12 +40,16 @@ from pendulum import (
     parse,
 )
 
+from ..log import get_logger
+
 if TYPE_CHECKING:
     from ._ledger import (
         Transaction,
         TransactionLedger,
     )
 
+log = get_logger(__name__)
+
 
 def ppu(
     clears: Iterator[Transaction],
@@ -238,6 +245,9 @@ def iter_by_dt(
 
     def dyn_parse_to_dt(
         tx: tuple[str, dict[str, Any]] | Transaction,
+
+        debug: bool = False,
+        _invalid: list|None = None,
     ) -> DateTime:
 
         # handle `.items()` inputs
@@ -250,33 +260,90 @@ def iter_by_dt(
         # get best parser for this record..
         for k in parsers:
             if (
-                isdict and k in tx
+                (v := getattr(tx, k, None))
-                 or getattr(tx, k, None)
+                or
+                (
+                    isdict
+                    and
+                    (v := tx.get(k))
+                )
             ):
-                v = tx[k] if isdict else tx.dt
-                assert v is not None, f'No valid value for `{k}`!?'
-
                 # only call parser on the value if not None from
                 # the `parsers` table above (when NOT using
                 # `.get()`), otherwise pass through the value and
                 # sort on it directly
                 if (
                     not isinstance(v, DateTime)
-                    and (parser := parsers.get(k))
+                    and
+                    (parser := parsers.get(k))
                 ):
-                    return parser(v)
+                    ret = parser(v)
                 else:
-                    return v
+                    ret = v
 
+                return ret
+
+            else:
+                log.debug(
+                    f'Parser-field not found in txn\n'
+                    f'\n'
+                    f'parser-field: {k!r}\n'
+                    f'txn: {tx!r}\n'
+                    f'\n'
+                    f'Trying next..\n'
+                )
+                continue
+
+        # XXX: we should never really get here bc it means some kinda
+        # bad txn-record (field) data..
+        #
+        # -> set the `debug_mode = True` if you want to trace such
+        # cases from REPL ;)
         else:
-            # XXX: should never get here..
+            # XXX: we should really never get here..
-            breakpoint()
+            # only if a ledger record has no expected sort(able)
+            # field will we likely hit this.. like with ze IB.
+            # if no sortable field just deliver epoch?
+            log.warning(
+                'No (time) sortable field for TXN:\n'
+                f'{tx!r}\n'
+            )
+            report: str = (
+                f'No supported time-field found in txn !?\n'
+                f'\n'
+                f'supported-time-fields: {parsers!r}\n'
+                f'\n'
+                f'txn: {tx!r}\n'
+            )
+            if debug:
+                with maybe_open_crash_handler(
+                    pdb=debug,
+                    raise_on_exit=False,
+                ):
+                    raise ValueError(report)
+            else:
+                log.error(report)
 
-    entry: tuple[str, dict] | Transaction
+            if _invalid is not None:
+                _invalid.append(tx)
+                return from_timestamp(0.)
+
+    entry: tuple[str, dict]|Transaction
+    invalid: list = []
     for entry in sorted(
         records,
-        key=key or dyn_parse_to_dt,
+        key=key or partial(
+            dyn_parse_to_dt,
+            _invalid=invalid,
+        ),
     ):
+        if entry in invalid:
+            log.warning(
+                f'Ignoring txn w invalid timestamp ??\n'
+                f'{pformat(entry)}\n'
+            )
+            continue
+
         # NOTE the type sig above; either pairs or txns B)
         yield entry
 
@@ -339,6 +406,7 @@ def open_ledger_dfs(
     acctname: str,
 
     ledger: TransactionLedger | None = None,
+    debug_mode: bool = False,
 
     **kwargs,
 
@@ -353,8 +421,10 @@ def open_ledger_dfs(
     can update the ledger on exit.
 
     '''
-    from piker.toolz import open_crash_handler
+    with maybe_open_crash_handler(
-    with open_crash_handler():
+        pdb=debug_mode,
+        # raise_on_exit=False,
+    ):
         if not ledger:
             import time
             from ._ledger import open_trade_ledger
@@ -446,7 +516,7 @@ def ledger_to_dfs(
 
         df = dfs[key] = ldf.with_columns([
 
-            pl.cumsum('size').alias('cumsize'),
+            pl.cum_sum('size').alias('cumsize'),
 
             # amount of source asset "sent" (via buy txns in
             # the market) to acquire the dst asset, PER txn.
@@ -461,7 +531,7 @@ def ledger_to_dfs(
         ]).with_columns([
 
             # rolling balance in src asset units
-            (pl.col('dst_bot').cumsum() * -1).alias('src_balance'),
+            (pl.col('dst_bot').cum_sum() * -1).alias('src_balance'),
 
             # "position operation type" in terms of increasing the
             # amount in the dst asset (entering) or decreasing the
@@ -603,7 +673,7 @@ def ledger_to_dfs(
                 # cost that was included in the least-recently
                 # entered txn that is still part of the current CSi
                 # set.
-                # => we look up the cost-per-unit cumsum and apply
+                # => we look up the cost-per-unit cum_sum and apply
                 # if over the current txn size (by multiplication)
                 # and then reverse that previusly applied cost on
                 # the txn_cost for this record.

piker/accounting/cli.py

@@ -300,7 +300,8 @@ def disect(
         assert not df.is_empty()
 
         # muck around in pdbp REPL
-        breakpoint()
+        # tractor.devx.mk_pdb().set_trace()
+        # breakpoint()
 
         # TODO: we REALLY need a better console REPL for this
         # kinda thing..

piker/brokers/__init__.py

@@ -98,13 +98,14 @@ async def open_cached_client(
     If one has not been setup do it and cache it.
 
     '''
-    brokermod = get_brokermod(brokername)
+    brokermod: ModuleType = get_brokermod(brokername)
+
+    # TODO: make abstract or `typing.Protocol`
+    # client: Client
     async with maybe_open_context(
         acm_func=brokermod.get_client,
         kwargs=kwargs,
-
     ) as (cache_hit, client):
-
         if cache_hit:
             log.runtime(f'Reusing existing {client}')
 

piker/brokers/_daemon.py

@@ -96,7 +96,10 @@ async def _setup_persistent_brokerd(
     # - `open_symbol_search()`
     # NOTE: see ep invocation details inside `.data.feed`.
     try:
-        async with trio.open_nursery() as service_nursery:
+        async with (
+            tractor.trionics.collapse_eg(),
+            trio.open_nursery() as service_nursery
+        ):
             bus: _FeedsBus = feed.get_feed_bus(
                 brokername,
                 service_nursery,

piker/brokers/binance/api.py

@@ -374,9 +374,14 @@ class Client:
                 pair: Pair = pair_type(**item)
             except Exception as e:
                 e.add_note(
-                    "\nDon't panic, prolly stupid binance changed their symbology schema again..\n"
+                    f'\n'
-                    'Check out their API docs here:\n\n'
+                    f'New or removed field we need to codify!\n'
-                    'https://binance-docs.github.io/apidocs/spot/en/#exchange-information'
+                    f'pair-type: {pair_type!r}\n'
+                    f'\n'
+                    f"Don't panic, prolly stupid binance changed their symbology schema again..\n"
+                    f'Check out their API docs here:\n'
+                    f'\n'
+                    f'https://binance-docs.github.io/apidocs/spot/en/#exchange-information\n'
                 )
                 raise
             pair_table[pair.symbol.upper()] = pair

piker/brokers/binance/broker.py

@@ -440,6 +440,7 @@ async def open_trade_dialog(
             #   - ledger: TransactionLedger
 
             async with (
+                tractor.trionics.collapse_eg(),
                 trio.open_nursery() as tn,
                 ctx.open_stream() as ems_stream,
             ):

piker/brokers/binance/feed.py

@@ -94,13 +94,15 @@ class L1(Struct):
 
 
 # validation type
+# https://developers.binance.com/docs/derivatives/usds-margined-futures/websocket-market-streams/Aggregate-Trade-Streams#response-example
 class AggTrade(Struct, frozen=True):
     e: str  # Event type
     E: int  # Event time
     s: str  # Symbol
     a: int  # Aggregate trade ID
     p: float  # Price
-    q: float  # Quantity
+    q: float  # Quantity with all the market trades
+    nq: float # Normal quantity without the trades involving RPI orders
     f: int  # First trade ID
     l: int  # noqa Last trade ID
     T: int  # Trade time
@@ -448,7 +450,6 @@ async def subscribe(
 
 
 async def stream_quotes(
-
     send_chan: trio.abc.SendChannel,
     symbols: list[str],
     feed_is_live: trio.Event,
@@ -460,6 +461,7 @@ async def stream_quotes(
 ) -> None:
 
     async with (
+        tractor.trionics.maybe_raise_from_masking_exc(),
         send_chan as send_chan,
         open_cached_client('binance') as client,
     ):

piker/brokers/binance/venues.py

@@ -97,6 +97,16 @@ class Pair(Struct, frozen=True, kw_only=True):
     baseAsset: str
     baseAssetPrecision: int
 
+    permissionSets: list[list[str]]
+
+    # https://developers.binance.com/docs/binance-spot-api-docs#2025-08-26
+    # will become non-optional 2025-08-28?
+    # https://developers.binance.com/docs/binance-spot-api-docs#future-changes
+    pegInstructionsAllowed: bool = False
+
+    # https://developers.binance.com/docs/binance-spot-api-docs#2025-12-02
+    opoAllowed: bool = False
+
     filters: dict[
         str,
         str | int | float,
@@ -142,7 +152,11 @@ class SpotPair(Pair, frozen=True):
     defaultSelfTradePreventionMode: str
     allowedSelfTradePreventionModes: list[str]
     permissions: list[str]
-    permissionSets: list[list[str]]
+
+    # can the paint botz creat liq gaps even easier on this asset?
+    # Bp
+    # https://developers.binance.com/docs/binance-spot-api-docs/faqs/order_amend_keep_priority
+    amendAllowed: bool
 
     # NOTE: see `.data._symcache.SymbologyCache.load()` for why
     ns_path: str = 'piker.brokers.binance:SpotPair'
@@ -209,7 +223,10 @@ class FutesPair(Pair):
                 assert pair == self.pair  # sanity
                 return f'{expiry}'
 
-            case 'PERPETUAL':
+            case (
+                'PERPETUAL'
+                | 'TRADIFI_PERPETUAL'
+            ):
                 return 'PERP'
 
             case '':
@@ -238,7 +255,10 @@ class FutesPair(Pair):
         margin: str = self.marginAsset
 
         match ctype:
-            case 'PERPETUAL':
+            case (
+                'PERPETUAL'
+                | 'TRADIFI_PERPETUAL'
+            ):
                 return f'{margin}M'
 
             case (

piker/brokers/cli.py

@@ -471,11 +471,15 @@ def search(
 
     '''
     # global opts
-    brokermods = list(config['brokermods'].values())
+    brokermods: list[ModuleType] = list(config['brokermods'].values())
+
+    # TODO: this is coming from the `search --pdb` NOT from
+    # the `piker --pdb` XD ..
+    # -[ ] pull from the parent click ctx's values..dumdum
+    # assert pdb
 
     # define tractor entrypoint
     async def main(func):
-
         async with maybe_open_pikerd(
             loglevel=config['loglevel'],
             debug_mode=pdb,

piker/brokers/core.py

@@ -22,7 +22,9 @@ routines should be primitive data types where possible.
 """
 import inspect
 from types import ModuleType
-from typing import List, Dict, Any, Optional
+from typing import (
+    Any,
+)
 
 import trio
 
@@ -34,8 +36,10 @@ from ..accounting import MktPair
 
 
 async def api(brokername: str, methname: str, **kwargs) -> dict:
-    """Make (proxy through) a broker API call by name and return its result.
+    '''
-    """
+    Make (proxy through) a broker API call by name and return its result.
+
+    '''
     brokermod = get_brokermod(brokername)
     async with brokermod.get_client() as client:
         meth = getattr(client, methname, None)
@@ -62,10 +66,14 @@ async def api(brokername: str, methname: str, **kwargs) -> dict:
 
 async def stocks_quote(
     brokermod: ModuleType,
-    tickers: List[str]
+    tickers: list[str]
-) -> Dict[str, Dict[str, Any]]:
+
-    """Return quotes dict for ``tickers``.
+) -> dict[str, dict[str, Any]]:
-    """
+    '''
+    Return a `dict` of snapshot quotes for the provided input
+    `tickers`: a `list` of fqmes.
+
+    '''
     async with brokermod.get_client() as client:
         return await client.quote(tickers)
 
@@ -74,13 +82,15 @@ async def stocks_quote(
 async def option_chain(
     brokermod: ModuleType,
     symbol: str,
-    date: Optional[str] = None,
+    date: str|None = None,
-) -> Dict[str, Dict[str, Dict[str, Any]]]:
+) -> dict[str, dict[str, dict[str, Any]]]:
-    """Return option chain for ``symbol`` for ``date``.
+    '''
+    Return option chain for ``symbol`` for ``date``.
 
     By default all expiries are returned. If ``date`` is provided
     then contract quotes for that single expiry are returned.
-    """
+
+    '''
     async with brokermod.get_client() as client:
         if date:
             id = int((await client.tickers2ids([symbol]))[symbol])
@@ -98,7 +108,7 @@ async def option_chain(
 # async def contracts(
 #     brokermod: ModuleType,
 #     symbol: str,
-# ) -> Dict[str, Dict[str, Dict[str, Any]]]:
+# ) -> dict[str, dict[str, dict[str, Any]]]:
 #     """Return option contracts (all expiries) for ``symbol``.
 #     """
 #     async with brokermod.get_client() as client:
@@ -110,15 +120,24 @@ async def bars(
     brokermod: ModuleType,
     symbol: str,
     **kwargs,
-) -> Dict[str, Dict[str, Dict[str, Any]]]:
+) -> dict[str, dict[str, dict[str, Any]]]:
-    """Return option contracts (all expiries) for ``symbol``.
+    '''
-    """
+    Return option contracts (all expiries) for ``symbol``.
+
+    '''
     async with brokermod.get_client() as client:
         return await client.bars(symbol, **kwargs)
 
 
-async def search_w_brokerd(name: str, pattern: str) -> dict:
+async def search_w_brokerd(
+    name: str,
+    pattern: str,
+) -> dict:
 
+    # TODO: WHY NOT WORK!?!
+    # when we `step` through the next block?
+    # import tractor
+    # await tractor.pause()
     async with open_cached_client(name) as client:
 
         # TODO: support multiple asset type concurrent searches.
@@ -130,12 +149,12 @@ async def symbol_search(
     pattern: str,
     **kwargs,
 
-) -> Dict[str, Dict[str, Dict[str, Any]]]:
+) -> dict[str, dict[str, dict[str, Any]]]:
     '''
     Return symbol info from broker.
 
     '''
-    results = []
+    results: list[str] = []
 
     async def search_backend(
         brokermod: ModuleType
@@ -143,6 +162,13 @@ async def symbol_search(
 
         brokername: str = mod.name
 
+        # TODO: figure this the FUCK OUT
+        # -> ok so obvi in the root actor any async task that's
+        # spawned outside the main tractor-root-actor task needs to
+        # call this..
+        # await tractor.devx._debug.maybe_init_greenback()
+        # tractor.pause_from_sync()
+
         async with maybe_spawn_brokerd(
             mod.name,
             infect_asyncio=getattr(
@@ -162,7 +188,6 @@ async def symbol_search(
             ))
 
     async with trio.open_nursery() as n:
-
         for mod in brokermods:
             n.start_soon(search_backend, mod.name)
 
@@ -172,11 +197,13 @@ async def symbol_search(
 async def mkt_info(
     brokermod: ModuleType,
     fqme: str,
+
     **kwargs,
 
 ) -> MktPair:
     '''
-    Return MktPair info from broker including src and dst assets.
+    Return the `piker.accounting.MktPair` info struct from a given
+    backend broker tradable src/dst asset pair.
 
     '''
     async with open_cached_client(brokermod.name) as client:

piker/brokers/deribit/api.py

@@ -31,7 +31,7 @@ from typing import (
     Callable,
 )
 
-import pendulum
+from pendulum import now
 import trio
 from trio_typing import TaskStatus
 from rapidfuzz import process as fuzzy
@@ -39,6 +39,7 @@ import numpy as np
 from tractor.trionics import (
     broadcast_receiver,
     maybe_open_context
+    collapse_eg,
 )
 from tractor import to_asyncio
 # XXX WOOPS XD
@@ -432,6 +433,7 @@ async def get_client(
 ) -> Client:
 
     async with (
+        collapse_eg(),
         trio.open_nursery() as n,
         open_jsonrpc_session(
             _testnet_ws_url, dtype=JSONRPCResult) as json_rpc

piker/brokers/ib/_util.py

@@ -20,6 +20,11 @@ runnable script-programs.
 
 '''
 from __future__ import annotations
+from datetime import (  # noqa
+    datetime,
+    date,
+    tzinfo as TzInfo,
+)
 from functools import partial
 from typing import (
     Literal,
@@ -33,7 +38,7 @@ from piker.brokers._util import get_logger
 
 if TYPE_CHECKING:
     from .api import Client
-    from ib_insync import IB
+    import i3ipc
 
 log = get_logger('piker.brokers.ib')
 
@@ -48,8 +53,39 @@ _reset_tech: Literal[
 ] = 'vnc'
 
 
+no_setup_msg:str = (
+    'No data reset hack test setup for {vnc_sockaddr}!\n'
+    'See config setup tips @\n'
+    'https://github.com/pikers/piker/tree/master/piker/brokers/ib'
+)
+
+
+def try_xdo_manual(
+    client: Client,
+):
+    '''
+    Do the "manual" `xdo`-based screen switch + click
+    combo since apparently the `asyncvnc` client ain't workin..
+
+    Note this is only meant as a backup method for Xorg users,
+    ideally you can use a real vnc client and the `vnc_click_hack()`
+    impl!
+
+    '''
+    global _reset_tech
+    try:
+        i3ipc_xdotool_manual_click_hack()
+        _reset_tech = 'i3ipc_xdotool'
+        return True
+    except OSError:
+        vnc_sockaddr: str = client.conf.vnc_addrs
+        log.exception(
+            no_setup_msg.format(vnc_sockaddr=vnc_sockaddr)
+        )
+        return False
+
+
 async def data_reset_hack(
-    # vnc_host: str,
     client: Client,
     reset_type: Literal['data', 'connection'],
 
@@ -81,65 +117,60 @@ async def data_reset_hack(
           that need to be wrangle.
 
     '''
-    ib_client: IB = client.ib
-
     # look up any user defined vnc socket address mapped from
     # a particular API socket port.
-    api_port: str = str(ib_client.client.port)
+    vnc_addrs: tuple[str]|None = client.conf.get('vnc_addrs')
-    vnc_host: str
+    if not vnc_addrs:
-    vnc_port: int
-    vnc_sockaddr: tuple[str] | None = client.conf.get('vnc_addrs')
-
-    no_setup_msg:str = (
-        f'No data reset hack test setup for {vnc_sockaddr}!\n'
-        'See config setup tips @\n'
-        'https://github.com/pikers/piker/tree/master/piker/brokers/ib'
-    )
-
-    if not vnc_sockaddr:
         log.warning(
-            no_setup_msg
+            no_setup_msg.format(vnc_sockaddr=client.conf)
             +
             'REQUIRES A `vnc_addrs: array` ENTRY'
         )
 
-    vnc_host, vnc_port = vnc_sockaddr.get(
-        api_port,
-        ('localhost', 3003)
-    )
     global _reset_tech
-
     match _reset_tech:
         case 'vnc':
             try:
                 await tractor.to_asyncio.run_task(
                     partial(
                         vnc_click_hack,
-                        host=vnc_host,
+                        client=client,
-                        port=vnc_port,
                     )
                 )
-            except OSError:
+            except (
-                if vnc_host != 'localhost':
+                OSError,  # no VNC server avail..
-                    log.warning(no_setup_msg)
+                PermissionError,  # asyncvnc pw fail..
-                    return False
+            ):
-
                 try:
                     import i3ipc  # noqa  (since a deps dynamic check)
                 except ModuleNotFoundError:
-                    log.warning(no_setup_msg)
+                    log.warning(
+                        no_setup_msg.format(vnc_sockaddr=client.conf)
+                    )
                     return False
 
-                try:
+                # XXX, Xorg only workaround..
-                    i3ipc_xdotool_manual_click_hack()
+                # TODO? remove now that we have `pyvnc`?
-                    _reset_tech = 'i3ipc_xdotool'
+                # if vnc_host not in {
-                    return True
+                #     'localhost',
-                except OSError:
+                #     '127.0.0.1',
-                    log.exception(no_setup_msg)
+                # }:
-                    return False
+                #     focussed, matches = i3ipc_fin_wins_titled()
+                #     if not matches:
+                #         log.warning(
+                #             no_setup_msg.format(vnc_sockaddr=vnc_sockaddr)
+                #         )
+                #         return False
+                #     else:
+                #         try_xdo_manual(vnc_sockaddr)
+
+                # localhost but no vnc-client or it borked..
+                else:
+                    try_xdo_manual(client)
 
         case 'i3ipc_xdotool':
-            i3ipc_xdotool_manual_click_hack()
+            try_xdo_manual(client)
+            # i3ipc_xdotool_manual_click_hack()
 
         case _ as tech:
             raise RuntimeError(f'{tech} is not supported for reset tech!?')
@@ -149,21 +180,66 @@ async def data_reset_hack(
 
 
 async def vnc_click_hack(
-    host: str,
+    client: Client,
-    port: int,
+    reset_type: str = 'data',
-    reset_type: str = 'data'
+    pw: str|None = None,
+
 ) -> None:
     '''
     Reset the data or network connection for the VNC attached
-    ib gateway using magic combos.
+    ib-gateway using a (magic) keybinding combo.
+
+    A vnc-server password can be set either by an input `pw` param or
+    set in the client's config with the latter loaded from the user's
+    `brokers.toml` in a vnc-addrs-port-mapping section,
+
+    .. code:: toml
+
+        [ib.vnc_addrs]
+        4002 = {host = 'localhost', port = 5900, pw = 'doggy'}
 
     '''
+    api_port: str = str(client.ib.client.port)
+    conf: dict = client.conf
+    vnc_addrs: dict[int, tuple] = conf.get('vnc_addrs')
+    if not vnc_addrs:
+        return None
+
+    addr_entry: dict|tuple = vnc_addrs.get(
+        api_port,
+        ('localhost', 5900)  # a typical default
+    )
+    if pw is None:
+        match addr_entry:
+            case (
+                host,
+                port,
+            ):
+                pass
+
+            case {
+                'host': host,
+                'port': port,
+                'pw': pw
+            }:
+                pass
+
+            case _:
+                raise ValueError(
+                    f'Invalid `ib.vnc_addrs` entry ?\n'
+                    f'{addr_entry!r}\n'
+                )
     try:
-        import asyncvnc
+        from pyvnc import (
+            AsyncVNCClient,
+            VNCConfig,
+            Point,
+            MOUSE_BUTTON_LEFT,
+        )
     except ModuleNotFoundError:
         log.warning(
             "In order to leverage `piker`'s built-in data reset hacks, install "
-            "the `asyncvnc` project: https://github.com/barneygale/asyncvnc"
+            "the `pyvnc` project: https://github.com/regulad/pyvnc.git"
         )
         return
 
@@ -174,24 +250,79 @@ async def vnc_click_hack(
         'connection': 'r'
     }[reset_type]
 
-    async with asyncvnc.connect(
+    with tractor.devx.open_crash_handler():
-        host,
+        client = await AsyncVNCClient.connect(
-        port=port,
+            VNCConfig(
-
+                host=host,
-        # TODO: doesn't work see:
+                port=port,
-        # https://github.com/barneygale/asyncvnc/issues/7
+                password=pw,
-        # password='ibcansmbz',
+            )
-
-    ) as client:
-
-        # move to middle of screen
-        # 640x1800
-        client.mouse.move(
-            x=500,
-            y=500,
         )
-        client.mouse.click()
+        async with client:
-        client.keyboard.press('Ctrl', 'Alt', key)  # keys are stacked
+            # move to middle of screen
+            # 640x1800
+            await client.move(
+                Point(
+                    500,
+                    500,
+                )
+            )
+            # ensure the ib-gw window is active
+            await client.click(MOUSE_BUTTON_LEFT)
+            # send the hotkeys combo B)
+            await client.press('Ctrl', 'Alt', key)  # keys are stacked
+
+
+def i3ipc_fin_wins_titled(
+    titles: list[str] = [
+        'Interactive Brokers',  # tws running in i3
+        'IB Gateway',  # gw running in i3
+        # 'IB',  # gw running in i3 (newer version?)
+
+        # !TODO, remote vnc instance
+        # -[ ] something in title (or other Con-props) that indicates
+        #   this is explicitly for ibrk sw?
+        #  |_[ ]  !can use modden spawn eventually!
+        'TigerVNC',
+        # 'vncviewer',  # the terminal..
+    ],
+) -> tuple[
+    i3ipc.Con,  # orig focussed win
+    list[tuple[str, i3ipc.Con]],  # matching wins by title
+]:
+    '''
+    Attempt to find a local-DE window titled with an entry in
+    `titles`.
+
+    If found deliver the current focussed window and all matching
+    `i3ipc.Con`s in a list.
+
+    '''
+    import i3ipc
+    ipc = i3ipc.Connection()
+
+    # TODO: might be worth offering some kinda api for grabbing
+    # the window id from the pid?
+    # https://stackoverflow.com/a/2250879
+    tree = ipc.get_tree()
+    focussed: i3ipc.Con = tree.find_focused()
+
+    matches: list[i3ipc.Con] = []
+    for name in titles:
+        results = tree.find_titled(name)
+        print(f'results for {name}: {results}')
+        if results:
+            con = results[0]
+            matches.append((
+                name,
+                con,
+            ))
+
+    return (
+        focussed,
+        matches,
+    )
+
 
 
 def i3ipc_xdotool_manual_click_hack() -> None:
@@ -199,65 +330,46 @@ def i3ipc_xdotool_manual_click_hack() -> None:
     Do the data reset hack but expecting a local X-window using `xdotool`.
 
     '''
-    import i3ipc
+    focussed, matches = i3ipc_fin_wins_titled()
-    i3 = i3ipc.Connection()
+    orig_win_id = focussed.window
-
-    # TODO: might be worth offering some kinda api for grabbing
-    # the window id from the pid?
-    # https://stackoverflow.com/a/2250879
-    t = i3.get_tree()
-
-    orig_win_id = t.find_focused().window
-
-    # for tws
-    win_names: list[str] = [
-        'Interactive Brokers',  # tws running in i3
-        'IB Gateway',  # gw running in i3
-        # 'IB',  # gw running in i3 (newer version?)
-    ]
-
     try:
-        for name in win_names:
+        for name, con in matches:
-            results = t.find_titled(name)
+            print(f'Resetting data feed for {name}')
-            print(f'results for {name}: {results}')
+            win_id = str(con.window)
-            if results:
+            w, h = con.rect.width, con.rect.height
-                con = results[0]
-                print(f'Resetting data feed for {name}')
-                win_id = str(con.window)
-                w, h = con.rect.width, con.rect.height
 
-                # TODO: seems to be a few libs for python but not sure
+            # TODO: seems to be a few libs for python but not sure
-                # if they support all the sub commands we need, order of
+            # if they support all the sub commands we need, order of
-                # most recent commit history:
+            # most recent commit history:
-                # https://github.com/rr-/pyxdotool
+            # https://github.com/rr-/pyxdotool
-                # https://github.com/ShaneHutter/pyxdotool
+            # https://github.com/ShaneHutter/pyxdotool
-                # https://github.com/cphyc/pyxdotool
+            # https://github.com/cphyc/pyxdotool
 
-                # TODO: only run the reconnect (2nd) kc on a detected
+            # TODO: only run the reconnect (2nd) kc on a detected
-                # disconnect?
+            # disconnect?
-                for key_combo, timeout in [
+            for key_combo, timeout in [
-                    # only required if we need a connection reset.
+                # only required if we need a connection reset.
-                    # ('ctrl+alt+r', 12),
+                # ('ctrl+alt+r', 12),
-                    # data feed reset.
+                # data feed reset.
-                    ('ctrl+alt+f', 6)
+                ('ctrl+alt+f', 6)
-                ]:
+            ]:
-                    subprocess.call([
+                subprocess.call([
-                        'xdotool',
+                    'xdotool',
-                        'windowactivate', '--sync', win_id,
+                    'windowactivate', '--sync', win_id,
 
-                        # move mouse to bottom left of window (where
+                    # move mouse to bottom left of window (where
-                        # there should be nothing to click).
+                    # there should be nothing to click).
-                        'mousemove_relative', '--sync', str(w-4), str(h-4),
+                    'mousemove_relative', '--sync', str(w-4), str(h-4),
 
-                        # NOTE: we may need to stick a `--retry 3` in here..
+                    # NOTE: we may need to stick a `--retry 3` in here..
-                        'click', '--window', win_id,
+                    'click', '--window', win_id,
-                        '--repeat', '3', '1',
+                    '--repeat', '3', '1',
 
-                        # hackzorzes
+                    # hackzorzes
-                        'key', key_combo,
+                    'key', key_combo,
-                        ],
+                    ],
-                        timeout=timeout,
+                    timeout=timeout,
-                    )
+                )
 
         # re-activate and focus original window
         subprocess.call([
@@ -267,3 +379,99 @@ def i3ipc_xdotool_manual_click_hack() -> None:
         ])
     except subprocess.TimeoutExpired:
         log.exception('xdotool timed out?')
+
+
+
+def is_current_time_in_range(
+    start_dt: datetime,
+    end_dt: datetime,
+) -> bool:
+    '''
+    Check if current time is within the datetime range.
+
+    Use any/the-same timezone as provided by `start_dt.tzinfo` value
+    in the range.
+
+    '''
+    now: datetime = datetime.now(start_dt.tzinfo)
+    return start_dt <= now <= end_dt
+
+
+# TODO, put this into `._util` and call it from here!
+#
+# NOTE, this was generated by @guille from a gpt5 prompt
+# and was originally thot to be needed before learning about
+# `ib_insync.contract.ContractDetails._parseSessions()` and
+# it's downstream meths..
+#
+# This is still likely useful to keep for now to parse the
+# `.tradingHours: str` value manually if we ever decide
+# to move off `ib_async` and implement our own `trio`/`anyio`
+# based version Bp
+#
+# >attempt to parse the retarted ib "time stampy thing" they
+# >do for "venue hours" with this.. written by
+# >gpt5-"thinking",
+#
+
+
+def parse_trading_hours(
+    spec: str,
+    tz: TzInfo|None = None
+) -> dict[
+    date,
+    tuple[datetime, datetime]
+]|None:
+    '''
+    Parse venue hours like:
+    'YYYYMMDD:HHMM-YYYYMMDD:HHMM;YYYYMMDD:CLOSED;...'
+
+    Returns `dict[date] = (open_dt, close_dt)` or `None` if
+    closed.
+
+    '''
+    if (
+        not isinstance(spec, str)
+        or
+        not spec
+    ):
+        raise ValueError('spec must be a non-empty string')
+
+    out: dict[
+        date,
+        tuple[datetime, datetime]
+    ]|None = {}
+
+    for part in (p.strip() for p in spec.split(';') if p.strip()):
+        if part.endswith(':CLOSED'):
+            day_s, _ = part.split(':', 1)
+            d = datetime.strptime(day_s, '%Y%m%d').date()
+            out[d] = None
+            continue
+
+        try:
+            start_s, end_s = part.split('-', 1)
+            start_dt = datetime.strptime(start_s, '%Y%m%d:%H%M')
+            end_dt = datetime.strptime(end_s, '%Y%m%d:%H%M')
+        except ValueError as exc:
+            raise ValueError(f'invalid segment: {part}') from exc
+
+        if tz is not None:
+            start_dt = start_dt.replace(tzinfo=tz)
+            end_dt = end_dt.replace(tzinfo=tz)
+
+        out[start_dt.date()] = (start_dt, end_dt)
+
+    return out
+
+
+# ORIG desired usage,
+#
+# TODO, for non-drunk tomorrow,
+# - call above fn and check that `output[today] is not None`
+# trading_hrs: dict = parse_trading_hours(
+#     details.tradingHours
+# )
+# liq_hrs: dict = parse_trading_hours(
+#     details.liquidHours
+    # )

piker/brokers/ib/api.py

@@ -48,6 +48,7 @@ from bidict import bidict
 import trio
 import tractor
 from tractor import to_asyncio
+from tractor import trionics
 from pendulum import (
     from_timestamp,
     DateTime,
@@ -333,15 +334,15 @@ class Client:
         fqme: str,
 
         # EST in ISO 8601 format is required... below is EPOCH
-        start_dt: datetime | str = "1970-01-01T00:00:00.000000-05:00",
+        start_dt: datetime|str = "1970-01-01T00:00:00.000000-05:00",
-        end_dt: datetime | str = "",
+        end_dt: datetime|str = "",
 
         # ohlc sample period in seconds
         sample_period_s: int = 1,
 
         # optional "duration of time" equal to the
         # length of the returned history frame.
-        duration: str | None = None,
+        duration: str|None = None,
 
         **kwargs,
 
@@ -715,8 +716,8 @@ class Client:
 
     async def find_contracts(
         self,
-        pattern: str | None = None,
+        pattern: str|None = None,
-        contract: Contract | None = None,
+        contract: Contract|None = None,
         qualify: bool = True,
         err_on_qualify: bool = True,
 
@@ -861,7 +862,7 @@ class Client:
         self,
         fqme: str,
 
-    ) -> datetime | None:
+    ) -> datetime|None:
         '''
         Return the first datetime stamp for `fqme` or `None`
         on request failure.
@@ -917,7 +918,7 @@ class Client:
         tries: int = 100,
         raise_on_timeout: bool = False,
 
-    ) -> Ticker | None:
+    ) -> Ticker|None:
         '''
         Return a single (snap) quote for symbol.
 
@@ -929,7 +930,7 @@ class Client:
         ready: ticker.TickerUpdateEvent = ticker.updateEvent
 
         # ensure a last price gets filled in before we deliver quote
-        timeouterr: Exception | None = None
+        timeouterr: Exception|None = None
         warnset: bool = False
         for _ in range(tries):
 
@@ -943,6 +944,7 @@ class Client:
                     )
                     if tkr:
                         break
+
                 except TimeoutError as err:
                     timeouterr = err
                     await asyncio.sleep(0.01)
@@ -951,7 +953,9 @@ class Client:
                 else:
                     if not warnset:
                         log.warning(
-                            f'Quote req timed out..maybe venue is closed?\n'
+                            f'Quote req timed out..\n'
+                            f'Maybe the venue is closed?\n'
+                            f'\n'
                             f'{asdict(contract)}'
                         )
                         warnset = True
@@ -963,9 +967,11 @@ class Client:
                 )
                 break
         else:
-            if timeouterr and raise_on_timeout:
+            if (
-                import pdbp
+                timeouterr
-                pdbp.set_trace()
+                and
+                raise_on_timeout
+            ):
                 raise timeouterr
 
             if not warnset:
@@ -1362,23 +1368,20 @@ async def load_aio_clients(
 
 
 async def load_clients_for_trio(
-    from_trio: asyncio.Queue,
+    chan: tractor.to_asyncio.LinkedTaskChannel,
-    to_trio: trio.abc.SendChannel,
-
 ) -> None:
     '''
     Pure async mngr proxy to ``load_aio_clients()``.
 
-    This is a bootstrap entrypoing to call from
+    This is a bootstrap entrypoint to call from
-    a ``tractor.to_asyncio.open_channel_from()``.
+    a `tractor.to_asyncio.open_channel_from()`.
 
     '''
     async with load_aio_clients(
         disconnect_on_exit=False,
     ) as accts2clients:
 
-        to_trio.send_nowait(accts2clients)
+        chan.started_nowait(accts2clients)
-
         # TODO: maybe a sync event to wait on instead?
         await asyncio.sleep(float('inf'))
 
@@ -1391,7 +1394,10 @@ async def open_client_proxies() -> tuple[
     async with (
         tractor.trionics.maybe_open_context(
             acm_func=tractor.to_asyncio.open_channel_from,
-            kwargs={'target': load_clients_for_trio},
+            kwargs={
+                'target': load_clients_for_trio,
+                # ^XXX, kwarg to `open_channel_from()`
+            },
 
             # lock around current actor task access
             # TODO: maybe this should be the default in tractor?
@@ -1501,7 +1507,7 @@ class MethodProxy:
         self,
         pattern: str,
 
-    ) -> dict[str, Any] | trio.Event:
+    ) -> dict[str, Any]|trio.Event:
 
         ev = self.event_table.get(pattern)
 
@@ -1522,23 +1528,22 @@ class MethodProxy:
 
 
 async def open_aio_client_method_relay(
-    from_trio: asyncio.Queue,
+    chan: tractor.to_asyncio.LinkedTaskChannel,
-    to_trio: trio.abc.SendChannel,
     client: Client,
     event_consumers: dict[str, trio.Event],
 
 ) -> None:
 
     # sync with `open_client_proxy()` caller
-    to_trio.send_nowait(client)
+    chan.started_nowait(client)
 
     # TODO: separate channel for error handling?
-    client.inline_errors(to_trio)
+    client.inline_errors(chan)
 
     # relay all method requests to ``asyncio``-side client and deliver
     # back results
-    while not to_trio._closed:
+    while not chan._to_trio._closed:  # <- TODO, better check like `._web_bs`?
-        msg: tuple[str, dict] | dict | None = await from_trio.get()
+        msg: tuple[str, dict]|dict|None = await chan.get()
         match msg:
             case None:  # termination sentinel
                 log.info('asyncio `Client` method-proxy SHUTDOWN!')
@@ -1551,7 +1556,7 @@ async def open_aio_client_method_relay(
                 try:
                     resp = await meth(**kwargs)
                     # echo the msg back
-                    to_trio.send_nowait({'result': resp})
+                    chan.send_nowait({'result': resp})
 
                 except (
                     RequestError,
@@ -1559,10 +1564,10 @@ async def open_aio_client_method_relay(
                     # TODO: relay all errors to trio?
                     # BaseException,
                 ) as err:
-                    to_trio.send_nowait({'exception': err})
+                    chan.send_nowait({'exception': err})
 
             case {'error': content}:
-                to_trio.send_nowait({'exception': content})
+                chan.send_nowait({'exception': content})
 
             case _:
                 raise ValueError(f'Unhandled msg {msg}')
@@ -1584,7 +1589,8 @@ async def open_client_proxy(
             event_consumers=event_table,
         ) as (first, chan),
 
-        trio.open_nursery() as relay_n,
+        trionics.collapse_eg(),  # loose-ify
+        trio.open_nursery() as relay_tn,
     ):
 
         assert isinstance(first, Client)
@@ -1624,7 +1630,7 @@ async def open_client_proxy(
 
                     continue
 
-        relay_n.start_soon(relay_events)
+        relay_tn.start_soon(relay_events)
 
         yield proxy
 

piker/brokers/ib/broker.py

@@ -34,6 +34,7 @@ import trio
 from trio_typing import TaskStatus
 import tractor
 from tractor.to_asyncio import LinkedTaskChannel
+from tractor import trionics
 from ib_insync.contract import (
     Contract,
 )
@@ -116,7 +117,11 @@ def pack_position(
             symbol=fqme,
             currency=con.currency,
             size=float(pos.position),
-            avg_price=float(pos.avgCost) / float(con.multiplier or 1.0),
+            avg_price=(
+                float(pos.avgCost)
+                /
+                float(con.multiplier or 1.0)
+            ),
         ),
     )
 
@@ -357,6 +362,10 @@ async def update_and_audit_pos_msg(
         size=ibpos.position,
 
         avg_price=pikerpos.ppu,
+
+        # XXX ensures matching even if multiple venue-names
+        # in `.bs_fqme`, likely from txn records..
+        bs_mktid=mkt.bs_mktid,
     )
 
     ibfmtmsg: str = pformat(ibpos._asdict())
@@ -407,7 +416,7 @@ async def update_and_audit_pos_msg(
 
     # TODO: make this a "propaganda" log level?
     if ibpos.avgCost != msg.avg_price:
-        log.warning(
+        log.debug(
             f'IB "FIFO" avg price for {msg.symbol} is DIFF:\n'
             f'ib: {ibfmtmsg}\n'
             '---------------------------\n'
@@ -425,7 +434,8 @@ async def aggr_open_orders(
 
 ) -> None:
     '''
-    Collect all open orders from client and fill in `order_msgs: list`.
+    Collect all open orders from client and fill in `order_msgs:
+    list`.
 
     '''
     trades: list[Trade] = client.ib.openTrades()
@@ -546,7 +556,10 @@ async def open_trade_dialog(
         ),
 
         # TODO: do this as part of `open_account()`!?
-        open_symcache('ib', only_from_memcache=True) as symcache,
+        open_symcache(
+            'ib',
+            only_from_memcache=True,
+        ) as symcache,
     ):
         # Open a trade ledgers stack for appending trade records over
         # multiple accounts.
@@ -554,8 +567,10 @@ async def open_trade_dialog(
         ledgers: dict[str, TransactionLedger] = {}
         tables: dict[str, Account] = {}
         order_msgs: list[Status] = []
-        conf = get_config()
+        conf: dict = get_config()
-        accounts_def_inv: bidict[str, str] = bidict(conf['accounts']).inverse
+        accounts_def_inv: bidict[str, str] = bidict(
+            conf['accounts']
+        ).inverse
 
         with (
             ExitStack() as lstack,
@@ -705,7 +720,11 @@ async def open_trade_dialog(
             # client-account and build out position msgs to deliver to
             # EMS.
             for acctid, acnt in tables.items():
-                active_pps, closed_pps = acnt.dump_active()
+                active_pps: dict[str, Position]
+                (
+                    active_pps,
+                    closed_pps,
+                ) = acnt.dump_active()
 
                 for pps in [active_pps, closed_pps]:
                     piker_pps: list[Position] = list(pps.values())
@@ -721,6 +740,7 @@ async def open_trade_dialog(
                         )
                         if ibpos:
                             bs_mktid: str = str(ibpos.contract.conId)
+
                             msg = await update_and_audit_pos_msg(
                                 acctid,
                                 pikerpos,
@@ -738,7 +758,7 @@ async def open_trade_dialog(
                                 f'UNEXPECTED POSITION says IB => {msg.symbol}\n'
                                 'Maybe they LIQUIDATED YOU or your ledger is wrong?\n'
                             )
-                            log.error(logmsg)
+                            log.debug(logmsg)
 
             await ctx.started((
                 all_positions,
@@ -747,21 +767,22 @@ async def open_trade_dialog(
 
             async with (
                 ctx.open_stream() as ems_stream,
-                trio.open_nursery() as n,
+                trionics.collapse_eg(),
+                trio.open_nursery() as tn,
             ):
                 # relay existing open orders to ems
                 for msg in order_msgs:
                     await ems_stream.send(msg)
 
                 for client in set(aioclients.values()):
-                    trade_event_stream: LinkedTaskChannel = await n.start(
+                    trade_event_stream: LinkedTaskChannel = await tn.start(
                         open_trade_event_stream,
                         client,
                     )
 
                     # start order request handler **before** local trades
                     # event loop
-                    n.start_soon(
+                    tn.start_soon(
                         handle_order_requests,
                         ems_stream,
                         accounts_def,
@@ -769,7 +790,7 @@ async def open_trade_dialog(
                     )
 
                     # allocate event relay tasks for each client connection
-                    n.start_soon(
+                    tn.start_soon(
                         deliver_trade_events,
 
                         trade_event_stream,
@@ -1241,32 +1262,47 @@ async def deliver_trade_events(
                 # never relay errors for non-broker related issues
                 # https://interactivebrokers.github.io/tws-api/message_codes.html
                 code: int = err['error_code']
-                if code in {
+                reason: str = err['reason']
-                    200,  # uhh
+                reqid: str = str(err['reqid'])
+
+                # "Warning:" msg codes,
+                # https://interactivebrokers.github.io/tws-api/message_codes.html#warning_codes
+                # - 2109: 'Outside Regular Trading Hours'
+                if 'Warning:' in reason:
+                    log.warning(
+                        f'Order-API-warning: {code!r}\n'
+                        f'reqid: {reqid!r}\n'
+                        f'\n'
+                        f'{pformat(err)}\n'
+                        # ^TODO? should we just print the `reason`
+                        # not the full `err`-dict?
+                    )
+                    continue
+
+                # XXX known special (ignore) cases
+                elif code in {
+                    200,  # uhh.. ni idea
 
                     # hist pacing / connectivity
                     162,
                     165,
 
-                    # WARNING codes:
-                    # https://interactivebrokers.github.io/tws-api/message_codes.html#warning_codes
-                    # Attribute 'Outside Regular Trading Hours' is
-                    # " 'ignored based on the order type and
-                    # destination. PlaceOrder is now ' 'being
-                    # processed.',
-                    2109,
-
                     # XXX: lol this isn't even documented..
                     # 'No market data during competing live session'
                     1669,
                 }:
+                    log.error(
+                        f'Order-API-error which is non-cancel-causing ?!\n'
+                        f'\n'
+                        f'{pformat(err)}\n'
+                    )
                     continue
 
-                reqid: str = str(err['reqid'])
-                reason: str = err['reason']
-
                 if err['reqid'] == -1:
-                    log.error(f'TWS external order error:\n{pformat(err)}')
+                    log.error(
+                        f'TWS external order error ??\n'
+                        f'{pformat(err)}\n'
+                    )
 
                 flow: dict = dict(
                     flows.get(reqid)

piker/brokers/ib/feed.py

@@ -1,5 +1,5 @@
 # piker: trading gear for hackers
-# Copyright (C) Tyler Goodlet (in stewardship for pikers)
+# Copyright (C) 2018-forever 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
@@ -13,10 +13,12 @@
 
 # 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/>.
-"""
-Data feed endpoints pre-wrapped and ready for use with ``tractor``/``trio``.
 
-"""
+'''
+Data feed endpoints pre-wrapped and ready for use with `tractor`/`trio`
+via "infected-asyncio-mode".
+
+'''
 from __future__ import annotations
 import asyncio
 from contextlib import (
@@ -26,7 +28,6 @@ from dataclasses import asdict
 from datetime import datetime
 from functools import partial
 from pprint import pformat
-from math import isnan
 import time
 from typing import (
     Any,
@@ -40,7 +41,6 @@ import numpy as np
 from pendulum import (
     now,
     from_timestamp,
-    # DateTime,
     Duration,
     duration as mk_duration,
 )
@@ -69,7 +69,10 @@ from .api import (
     Contract,
     RequestError,
 )
-from ._util import data_reset_hack
+from ._util import (
+    data_reset_hack,
+    is_current_time_in_range,
+)
 from .symbols import get_mkt_info
 
 if TYPE_CHECKING:
@@ -184,7 +187,8 @@ async def open_history_client(
 
             if (
                 start_dt
-                and start_dt.timestamp() == 0
+                and
+                start_dt.timestamp() == 0
             ):
                 await tractor.pause()
 
@@ -203,14 +207,16 @@ async def open_history_client(
             ):
                 count += 1
                 mean += latency / count
-                print(
+                log.debug(
                     f'HISTORY FRAME QUERY LATENCY: {latency}\n'
                     f'mean: {mean}'
                 )
 
             # could be trying to retreive bars over weekend
             if out is None:
-                log.error(f"Can't grab bars starting at {end_dt}!?!?")
+                log.error(
+                    f"No bars starting at {end_dt!r} !?!?"
+                )
                 if (
                     end_dt
                     and head_dt
@@ -285,8 +291,9 @@ _pacing: str = (
 
 async def wait_on_data_reset(
     proxy: MethodProxy,
+
     reset_type: str = 'data',
-    timeout: float = 16, # float('inf'),
+    timeout: float = 16,
 
     task_status: TaskStatus[
         tuple[
@@ -295,29 +302,47 @@ async def wait_on_data_reset(
         ]
     ] = trio.TASK_STATUS_IGNORED,
 ) -> bool:
+    '''
+    Wait on a (global-ish) "data-farm" event to be emitted
+    by the IB api server.
 
-    # TODO: we might have to put a task lock around this
+    Allows syncing to reconnect event-messages emitted on the API
-    # method..
+    console, such as:
-    hist_ev = proxy.status_event(
+
+     - 'HMDS data farm connection is OK:ushmds'
+     - 'Market data farm is connecting:usfuture'
+     - 'Market data farm connection is OK:usfuture'
+
+     Deliver a `(cs, done: Event)` pair to the caller to support it
+     waiting or cancelling the associated "data-reset-request";
+     normally a manual data-reset-req is expected to be the cause and
+     thus trigger such events (such as our click-hack-magic from
+     `.ib._util`).
+
+    '''
+    # ?TODO, do we need a task-lock around this method?
+    #
+    # register for an API "status event" wrapped for `trio`-sync.
+    hist_ev: trio.Event = proxy.status_event(
         'HMDS data farm connection is OK:ushmds'
     )
-
+    #
-    # TODO: other event messages we might want to try and
+    # ^TODO: other event-messages we might want to support waiting-for
-    # wait for but i wasn't able to get any of this
+    # but i wasn't able to get reliable..
-    # reliable..
+    #
     # reconnect_start = proxy.status_event(
     #     'Market data farm is connecting:usfuture'
     # )
     # live_ev = proxy.status_event(
     #     'Market data farm connection is OK:usfuture'
     # )
+
     # try to wait on the reset event(s) to arrive, a timeout
     # will trigger a retry up to 6 times (for now).
     client: Client = proxy._aio_ns
 
     done = trio.Event()
     with trio.move_on_after(timeout) as cs:
-
         task_status.started((cs, done))
 
         log.warning(
@@ -396,8 +421,9 @@ async def get_bars(
     bool,  # timed out hint
 ]:
     '''
-    Retrieve historical data from a ``trio``-side task using
+    Request-n-retrieve historical data frames from a `trio.Task`
-    a ``MethoProxy``.
+    using a `MethoProxy` to query the `asyncio`-side's
+    `.ib.api.Client` methods.
 
     '''
     global _data_resetter_task, _failed_resets
@@ -587,7 +613,7 @@ async def get_bars(
                         data_cs.cancel()
 
                     # spawn new data reset task
-                    data_cs, reset_done = await nurse.start(
+                    data_cs, reset_done = await tn.start(
                         partial(
                             wait_on_data_reset,
                             proxy,
@@ -607,11 +633,14 @@ async def get_bars(
     # such that simultaneous symbol queries don't try data resettingn
     # too fast..
     unset_resetter: bool = False
-    async with trio.open_nursery() as nurse:
+    async with (
+        tractor.trionics.collapse_eg(),
+        trio.open_nursery() as tn
+    ):
 
         # start history request that we allow
         # to run indefinitely until a result is acquired
-        nurse.start_soon(query)
+        tn.start_soon(query)
 
         # start history reset loop which waits up to the timeout
         # for a result before triggering a data feed reset.
@@ -631,7 +660,7 @@ async def get_bars(
                 unset_resetter: bool = True
 
             # spawn new data reset task
-            data_cs, reset_done = await nurse.start(
+            data_cs, reset_done = await tn.start(
                 partial(
                     wait_on_data_reset,
                     proxy,
@@ -653,14 +682,12 @@ async def get_bars(
     )
 
 
+# per-actor cache of inter-eventloop-chans
 _quote_streams: dict[str, trio.abc.ReceiveStream] = {}
 
 
 async def _setup_quote_stream(
-
+    chan: tractor.to_asyncio.LinkedTaskChannel,
-    from_trio: asyncio.Queue,
-    to_trio: trio.abc.SendChannel,
-
     symbol: str,
     opts: tuple[int] = (
         '375',  # RT trade volume (excludes utrades)
@@ -678,10 +705,13 @@ async def _setup_quote_stream(
 
 ) -> trio.abc.ReceiveChannel:
     '''
-    Stream a ticker using the std L1 api.
+    Stream L1 quotes via the `Ticker.updateEvent.connect(push)`
+    callback API by registering a `push` callback which simply
+    `chan.send_nowait()`s quote msgs back to the calling
+    parent-`trio.Task`-side.
 
-    This task is ``asyncio``-side and must be called from
+    NOTE, that this task-fn is run on the `asyncio.Task`-side ONLY
-    ``tractor.to_asyncio.open_channel_from()``.
+    and is thus run via `tractor.to_asyncio.open_channel_from()`.
 
     '''
     global _quote_streams
@@ -689,37 +719,79 @@ async def _setup_quote_stream(
     async with load_aio_clients(
         disconnect_on_exit=False,
     ) as accts2clients:
-        caccount_name, client = get_preferred_data_client(accts2clients)
-        contract = contract or (await client.find_contract(symbol))
-        to_trio.send_nowait(contract)  # cuz why not
-        ticker: Ticker = client.ib.reqMktData(contract, ','.join(opts))
 
-        # NOTE: it's batch-wise and slow af but I guess could
+        # XXX since this is an `asyncio.Task`, we must use
-        # be good for backchecking? Seems to be every 5s maybe?
+        # tractor.pause_from_sync()
+
+        caccount_name, client = get_preferred_data_client(accts2clients)
+        contract = (
+            contract
+            or
+            (await client.find_contract(symbol))
+        )
+        chan.started_nowait(contract)  # cuz why not
+        ticker: Ticker = client.ib.reqMktData(
+            contract,
+            ','.join(opts),
+        )
+        maybe_exc: BaseException|None = None
+        handler_tries: int = 0
+        aio_task: asyncio.Task = asyncio.current_task()
+
+        # ?TODO? this API is batch-wise and quite slow-af but,
+        # - seems to be 5s updates?
+        # - maybe we could use it for backchecking?
+        #
         # ticker: Ticker = client.ib.reqTickByTickData(
         #     contract, 'Last',
         # )
 
-        # # define a simple queue push routine that streams quote packets
+        # define a very naive queue-pushing callback that relays
-        # # to trio over the ``to_trio`` memory channel.
+        # quote-packets directly the calling (parent) `trio.Task`.
-        # to_trio, from_aio = trio.open_memory_channel(2**8)  # type: ignore
+        # Ensure on teardown we cancel the feed via their cancel API.
+        #
         def teardown():
+            '''
+            Disconnect our `push`-er callback and cancel the data-feed
+            for `contract`.
+
+            '''
+            nonlocal maybe_exc
             ticker.updateEvent.disconnect(push)
-            log.error(f"Disconnected stream for `{symbol}`")
+            report: str = f'Disconnected mkt-data for {symbol!r} due to '
+            if maybe_exc is not None:
+                report += (
+                    'error,\n'
+                    f'{maybe_exc!r}\n'
+                )
+                log.error(report)
+            else:
+                report += (
+                    'cancellation.\n'
+                )
+                log.cancel(report)
+
             client.ib.cancelMktData(contract)
 
             # decouple broadcast mem chan
             _quote_streams.pop(symbol, None)
 
-        def push(t: Ticker) -> None:
+        def push(
-            """
+            t: Ticker,
-            Push quotes to trio task.
+            tries_before_raise: int = 6,
+        ) -> None:
+            '''
+            Push quotes verbatim to parent-side `trio.Task`.
 
-            """
+            '''
-            # log.debug(t)
+            nonlocal maybe_exc, handler_tries
+            # log.debug(f'new IB quote: {t}\n')
             try:
-                to_trio.send_nowait(t)
+                chan.send_nowait(t)
 
+                # XXX TODO XXX replicate in `tractor` tests
+                # as per `CancelledError`-handler notes below!
+                # assert 0
             except (
                 trio.BrokenResourceError,
 
@@ -734,35 +806,107 @@ async def _setup_quote_stream(
                 # resulting in tracebacks spammed to console..
                 # Manually do the dereg ourselves.
                 teardown()
-            except trio.WouldBlock:
-                # log.warning(
-                #     f'channel is blocking symbol feed for {symbol}?'
-                #     f'\n{to_trio.statistics}'
-                # )
-                pass
 
-            # except trio.WouldBlock:
+            # for slow debugging purposes to avoid clobbering prompt
-            #     # for slow debugging purposes to avoid clobbering prompt
+            # with log msgs
-            #     # with log msgs
+            except trio.WouldBlock:
-            #     pass
+                log.exception(
+                    f'Asyncio->Trio `chan.send_nowait()` blocked !?\n'
+                    f'\n'
+                    f'{chan._to_trio.statistics()}\n'
+                )
+
+            # ?TODO, handle re-connection attempts?
+            except BaseException as _berr:
+                berr = _berr
+                if handler_tries >= tries_before_raise:
+                    # breakpoint()
+                    maybe_exc = _berr
+                    # task.set_exception(berr)
+                    aio_task.cancel(msg=berr.args)
+                    raise berr
+                else:
+                    handler_tries += 1
+
+                log.exception(
+                    f'Failed to push ticker quote !?\n'
+                    f'handler_tries={handler_tries!r}\n'
+                    f'ticker: {t!r}\n'
+                    f'\n'
+                    f'{chan._to_trio.statistics()}\n'
+                    f'\n'
+                    f'CAUSE: {berr}\n'
+                )
+
 
         ticker.updateEvent.connect(push)
         try:
             await asyncio.sleep(float('inf'))
-        finally:
-            teardown()
 
-        # return from_aio
+            # XXX, for debug.. TODO? can we rm again?
+            #
+            # tractor.pause_from_sync()
+            # while True:
+            #     await asyncio.sleep(1.6)
+            #     if ticker.ticks:
+            #         log.debug(
+            #             f'ticker.ticks = \n'
+            #             f'{ticker.ticks}\n'
+            #         )
+            #     else:
+            #         log.warning(
+            #             'UHH no ticker.ticks ??'
+            #         )
+
+        # XXX TODO XXX !?!?
+        # apparently **without this handler** and the subsequent
+        # re-raising of `maybe_exc from _taskc` cancelling the
+        # `aio_task` from the `push()`-callback will cause a very
+        # strange chain of exc raising that breaks alll sorts of
+        # downstream callers, tasks and remote-actor tasks!?
+        #
+        # -[ ] we need some lowlevel reproducting tests to replicate
+        #      those worst-case scenarios in `tractor` core!!
+        # -[ ] likely we should factor-out the `tractor.to_asyncio`
+        #      attempts at workarounds in `.translate_aio_errors()`
+        #      for failed `asyncio.Task.set_exception()` to either
+        #      call `aio_task.cancel()` and/or
+        #      `aio_task._fut_waiter.set_exception()` to a re-useable
+        #      toolset in something like a `.to_asyncio._utils`??
+        #
+        except asyncio.CancelledError as _taskc:
+            if maybe_exc is not None:
+                raise maybe_exc from _taskc
+
+            raise _taskc
+
+        except BaseException as _berr:
+            # stash any crash cause for reporting in `teardown()`
+            maybe_exc = _berr
+            raise _berr
+
+        finally:
+            # always disconnect our `push()` and cancel the
+            # ib-"mkt-data-feed".
+            teardown()
 
 
 @acm
 async def open_aio_quote_stream(
-
     symbol: str,
-    contract: Contract | None = None,
+    contract: Contract|None = None,
 
-) -> trio.abc.ReceiveStream:
+) -> (
+    trio.abc.Channel|  # iface
+    tractor.to_asyncio.LinkedTaskChannel  # actually
+):
+    '''
+    Open a real-time `Ticker` quote stream from an `asyncio.Task`
+    spawned via `tractor.to_asyncio.open_channel_from()`, deliver the
+    inter-event-loop channel to the `trio.Task` caller and cache it
+    globally for re-use.
 
+    '''
     from tractor.trionics import broadcast_receiver
     global _quote_streams
 
@@ -778,6 +922,7 @@ async def open_aio_quote_stream(
             yield from_aio
             return
 
+    from_aio: tractor.to_asyncio.LinkedTaskChannel
     async with tractor.to_asyncio.open_channel_from(
         _setup_quote_stream,
         symbol=symbol,
@@ -787,6 +932,10 @@ async def open_aio_quote_stream(
 
         assert contract
 
+        # TODO? de-reg on teardown of last consumer task?
+        # -> why aren't we using `.trionics.maybe_open_context()`
+        # here again?? (we are in `open_client_proxies()` tho?)
+        #
         # cache feed for later consumers
         _quote_streams[symbol] = from_aio
 
@@ -801,7 +950,12 @@ def normalize(
     calc_price: bool = False
 
 ) -> dict:
+    '''
+    Translate `ib_async`'s `Ticker.ticks` values to a `piker`
+    normalized `dict` form for transmit to downstream `.data` layer
+    consumers.
 
+    '''
     # check for special contract types
     con = ticker.contract
     fqme, calc_price = con2fqme(con)
@@ -820,7 +974,7 @@ def normalize(
 
             tbt = ticker.tickByTicks
             if tbt:
-                print(f'tickbyticks:\n {ticker.tickByTicks}')
+                log.info(f'tickbyticks:\n {ticker.tickByTicks}')
 
     ticker.ticks = new_ticks
 
@@ -856,27 +1010,39 @@ def normalize(
     return data
 
 
+# ?TODO? feels like this task-fn could be factored to reduce some
+# indentation levels?
+# -[ ] the reconnect while loop on ib-gw "data farm connection.."s
+# -[ ] everything embedded under the `async with aclosing(stream):`
+#     as the "meat" of the quote delivery once the connection is
+#     stable.
+#
 async def stream_quotes(
-
     send_chan: trio.abc.SendChannel,
     symbols: list[str],
     feed_is_live: trio.Event,
-    loglevel: str = None,
+
+    # TODO? we need to hook into the `ib_async` logger like
+    # we can with i3ipc from modden!
+    # loglevel: str|None = None,
 
     # startup sync
     task_status: TaskStatus[tuple[dict, dict]] = trio.TASK_STATUS_IGNORED,
 
 ) -> None:
     '''
-    Stream symbol quotes.
+    Stream `symbols[0]` quotes back via `send_chan`.
 
-    This is a ``trio`` callable routine meant to be invoked
+    The `feed_is_live: Event` is set to signal the caller that it can
-    once the brokerd is up.
+    begin processing msgs from the mem-chan.
 
     '''
     # TODO: support multiple subscriptions
-    sym = symbols[0]
+    sym: str = symbols[0]
-    log.info(f'request for real-time quotes: {sym}')
+    log.info(
+        f'request for real-time quotes\n'
+        f'sym: {sym!r}\n'
+    )
 
     init_msgs: list[FeedInit] = []
 
@@ -885,34 +1051,52 @@ async def stream_quotes(
     details: ibis.ContractDetails
     async with (
         open_data_client() as proxy,
-        # trio.open_nursery() as tn,
     ):
         mkt, details = await get_mkt_info(
             sym,
             proxy=proxy,  # passed to avoid implicit client load
         )
 
+        # is venue active rn?
+        venue_is_open: bool = any(
+            is_current_time_in_range(
+                start_dt=sesh.start,
+                end_dt=sesh.end,
+            )
+            for sesh in details.tradingSessions()
+        )
+
         init_msg = FeedInit(mkt_info=mkt)
 
+        # NOTE, tell sampler (via config) to skip vlm summing for dst
+        # assets which provide no vlm data..
         if mkt.dst.atype in {
             'fiat',
             'index',
             'commodity',
         }:
-            # tell sampler config that it shouldn't do vlm summing.
             init_msg.shm_write_opts['sum_tick_vlm'] = False
             init_msg.shm_write_opts['has_vlm'] = False
 
         init_msgs.append(init_msg)
 
         con: Contract = details.contract
-        first_ticker: Ticker | None = None
+        first_ticker: Ticker|None = None
-        with trio.move_on_after(1):
+
+        timeout: float = 1.6
+        with trio.move_on_after(timeout) as quote_cs:
             first_ticker: Ticker = await proxy.get_quote(
                 contract=con,
                 raise_on_timeout=False,
             )
 
+        # XXX should never happen with this ep right?
+        # but if so then, more then likely mkt is closed?
+        if quote_cs.cancelled_caught:
+            log.warning(
+                f'First quote req timed out after {timeout!r}s'
+            )
+
         if first_ticker:
             first_quote: dict = normalize(first_ticker)
 
@@ -924,28 +1108,27 @@ async def stream_quotes(
                 f'{pformat(first_quote)}\n'
             )
 
-        # NOTE: it might be outside regular trading hours for
+        # XXX NOTE: whenever we're "outside regular trading hours"
-        # assets with "standard venue operating hours" so we
+        # (only relevant for assets coming from the "legacy markets"
-        # only "pretend the feed is live" when the dst asset
+        # space) so we basically (from an API/runtime-operational
-        # type is NOT within the NON-NORMAL-venue set: aka not
+        # perspective) "pretend the feed is live" even if it's
-        # commodities, forex or crypto currencies which CAN
+        # actually closed.
-        # always return a NaN on a snap quote request during
+        #
-        # normal venue hours. In the case of a closed venue
+        # IOW, we signal to the effective caller (task) that the live
-        # (equitiies, futes, bonds etc.) we at least try to
+        # feed is "already up" but really we're just indicating that
-        # grab the OHLC history.
+        # the OHLCV history can start being loaded immediately by the
-        if (
+        # `piker.data`/`.tsp` layers.
-            first_ticker
+        #
-            and
+        # XXX, deats: the "pretend we're live" is just done by
-            isnan(first_ticker.last)
+        # a `feed_is_live.set()` even though nothing is actually live
-            # SO, if the last quote price value is NaN we ONLY
+        # Bp
-            # "pretend to do" `feed_is_live.set()` if it's a known
+        if not venue_is_open:
-            # dst asset venue with a lot of closed operating hours.
+            log.warning(
-            and mkt.dst.atype not in {
+                f'Venue is closed, unable to establish real-time feed.\n'
-                'commodity',
+                f'mkt: {mkt!r}\n'
-                'fiat',
+                f'\n'
-                'crypto',
+                f'first_ticker: {first_ticker}\n'
-            }
+            )
-        ):
             task_status.started((
                 init_msgs,
                 first_quote,
@@ -956,10 +1139,12 @@ async def stream_quotes(
             feed_is_live.set()
 
             # block and let data history backfill code run.
+            # XXX obvi given the venue is closed, we never expect feed
+            # to come up; a taskc should be the only way to
+            # terminate this task.
             await trio.sleep_forever()
-            return  # we never expect feed to come up?
 
-        # TODO: we should instead spawn a task that waits on a feed
+        # ?TODO, we could instead spawn a task that waits on a feed
         # to start and let it wait indefinitely..instead of this
         # hard coded stuff.
         # async def wait_for_first_quote():
@@ -981,23 +1166,27 @@ async def stream_quotes(
             'Rxed init quote:\n'
             f'{pformat(first_quote)}'
         )
-        cs: trio.CancelScope | None = None
+        cs: trio.CancelScope|None = None
         startup: bool = True
+        iter_quotes: trio.abc.Channel
         while (
             startup
-            or cs.cancel_called
+            or
+            cs.cancel_called
         ):
             with trio.CancelScope() as cs:
                 async with (
-                    trio.open_nursery() as nurse,
+                    tractor.trionics.collapse_eg(),
+                    trio.open_nursery() as tn,
                     open_aio_quote_stream(
                         symbol=sym,
                         contract=con,
-                    ) as stream,
+                    ) as iter_quotes,
                 ):
+                    # ?TODO? can we rm this - particularly for `ib_async`?
                     # ugh, clear ticks since we've consumed them
                     # (ahem, ib_insync is stateful trash)
-                    first_ticker.ticks = []
+                    # first_ticker.ticks = []
 
                     # only on first entry at feed boot up
                     if startup:
@@ -1011,8 +1200,8 @@ async def stream_quotes(
                     # data feed event.
                     async def reset_on_feed():
 
-                        # TODO: this seems to be surpressed from the
+                        # ??TODO? this seems to be surpressed from the
-                        # traceback in ``tractor``?
+                        # traceback in `tractor`?
                         # assert 0
 
                         rt_ev = proxy.status_event(
@@ -1021,9 +1210,9 @@ async def stream_quotes(
                         await rt_ev.wait()
                         cs.cancel()  # cancel called should now be set
 
-                    nurse.start_soon(reset_on_feed)
+                    tn.start_soon(reset_on_feed)
 
-                    async with aclosing(stream):
+                    async with aclosing(iter_quotes):
                         # if syminfo.get('no_vlm', False):
                         if not init_msg.shm_write_opts['has_vlm']:
 
@@ -1038,25 +1227,27 @@ async def stream_quotes(
                             # wait for real volume on feed (trading might be
                             # closed)
                             while True:
-                                ticker = await stream.receive()
+                                ticker = await iter_quotes.receive()
 
                                 # for a real volume contract we rait for
                                 # the first "real" trade to take place
                                 if (
                                     # not calc_price
                                     # and not ticker.rtTime
-                                    not ticker.rtTime
+                                    False
+                                    # not ticker.rtTime
                                 ):
                                     # spin consuming tickers until we
                                     # get a real market datum
                                     log.debug(f"New unsent ticker: {ticker}")
                                     continue
+
                                 else:
                                     log.debug("Received first volume tick")
                                     # ugh, clear ticks since we've
                                     # consumed them (ahem, ib_insync is
                                     # truly stateful trash)
-                                    ticker.ticks = []
+                                    # ticker.ticks = []
 
                                     # XXX: this works because we don't use
                                     # ``aclosing()`` above?
@@ -1066,15 +1257,24 @@ async def stream_quotes(
                             log.debug(f"First ticker received {quote}")
 
                         # tell data-layer spawner-caller that live
-                        # quotes are now streaming.
+                        # quotes are now active desptie not having
+                        # necessarily received a first vlm/clearing
+                        # tick.
+                        ticker = await iter_quotes.receive()
                         feed_is_live.set()
+                        fqme: str = quote['fqme']
+                        await send_chan.send({fqme: quote})
 
                         # last = time.time()
-                        async for ticker in stream:
+                        async for ticker in iter_quotes:
                             quote = normalize(ticker)
-                            fqme = quote['fqme']
+                            fqme: str = quote['fqme']
+                            log.debug(
+                                f'Sending quote\n'
+                                f'{quote}'
+                            )
                             await send_chan.send({fqme: quote})
 
                             # ugh, clear ticks since we've consumed them
-                            ticker.ticks = []
+                            # ticker.ticks = []
                             # last = time.time()

piker/brokers/kraken/api.py

@@ -34,6 +34,7 @@ import urllib.parse
 import hashlib
 import hmac
 import base64
+import tractor
 import trio
 
 from piker import config
@@ -372,8 +373,7 @@ class Client:
         #     1658347714, 'status': 'Success'}]}
 
         if xfers:
-            import tractor
+            await tractor.pause()
-            await tractor.pp()
 
         trans: dict[str, Transaction] = {}
         for entry in xfers:
@@ -501,7 +501,8 @@ class Client:
             for xkey, data in resp['result'].items():
 
                 # NOTE: always cache in pairs tables for faster lookup
-                pair = Pair(xname=xkey, **data)
+                with tractor.devx.maybe_open_crash_handler(): # as bxerr:
+                    pair = Pair(xname=xkey, **data)
 
                 # register the above `Pair` structs for all
                 # key-sets/monikers: a set of 4 (frickin) tables

piker/brokers/kraken/broker.py

@@ -175,9 +175,8 @@ async def handle_order_requests(
 
             case {
                 'account': 'kraken.spot' as account,
-                'action': action,
+                'action': 'buy'|'sell',
-            } if action in {'buy', 'sell'}:
+            }:
-
                 # validate
                 order = BrokerdOrder(**msg)
 
@@ -262,6 +261,12 @@ async def handle_order_requests(
                 } | extra
 
                 log.info(f'Submitting WS order request:\n{pformat(req)}')
+
+                # NOTE HOWTO, debug order requests
+                #
+                # if 'XRP' in pair:
+                #     await tractor.pause()
+
                 await ws.send_msg(req)
 
                 # placehold for sanity checking in relay loop
@@ -544,7 +549,7 @@ async def open_trade_dialog(
             # to be reloaded.
             balances: dict[str, float] = await client.get_balances()
 
-            verify_balances(
+            await verify_balances(
                 acnt,
                 src_fiat,
                 balances,
@@ -1085,6 +1090,8 @@ async def handle_order_updates(
                         f'Failed to {action} order {reqid}:\n'
                         f'{errmsg}'
                     )
+                    # if tractor._state.debug_mode():
+                    #     await tractor.pause()
 
                     symbol: str = 'N/A'
                     if chain := apiflows.get(reqid):

piker/brokers/kraken/symbols.py

@@ -21,7 +21,6 @@ Symbology defs and search.
 from decimal import Decimal
 
 import tractor
-from rapidfuzz import process as fuzzy
 
 from piker._cacheables import (
     async_lifo_cache,
@@ -41,8 +40,13 @@ from piker.accounting._mktinfo import (
 )
 
 
-# https://www.kraken.com/features/api#get-tradable-pairs
 class Pair(Struct):
+    '''
+    A tradable asset pair as schema-defined by,
+
+    https://docs.kraken.com/api/docs/rest-api/get-tradable-asset-pairs
+
+    '''
     xname: str  # idiotic bs_mktid equiv i guess?
     altname: str  # alternate pair name
     wsname: str  # WebSocket pair name (if available)
@@ -53,7 +57,6 @@ class Pair(Struct):
     lot: str  # volume lot size
 
     cost_decimals: int
-    costmin: float
     pair_decimals: int  # scaling decimal places for pair
     lot_decimals: int  # scaling decimal places for volume
 
@@ -79,6 +82,7 @@ class Pair(Struct):
     tick_size: float  # min price step size
     status: str
 
+    costmin: str|None = None  # XXX, only some mktpairs?
     short_position_limit: float = 0
     long_position_limit: float = float('inf')
 

piker/brokers/questrade.py

@@ -37,6 +37,12 @@ import tractor
 from async_generator import asynccontextmanager
 import numpy as np
 import wrapt
+
+# TODO, port to `httpx`/`trio-websocket` whenver i get back to
+# writing a proper ws-api streamer for this backend (since the data
+# feeds are free now) as per GH feat-req:
+# https://github.com/pikers/piker/issues/509
+#
 import asks
 
 from ..calc import humanize, percent_change

piker/clearing/_client.py

@@ -25,7 +25,10 @@ from typing import TYPE_CHECKING
 
 import trio
 import tractor
-from tractor.trionics import broadcast_receiver
+from tractor.trionics import (
+    broadcast_receiver,
+    collapse_eg,
+)
 
 from ._util import (
     log,  # sub-sys logger
@@ -168,7 +171,6 @@ class OrderClient(Struct):
 
 
 async def relay_orders_from_sync_code(
-
     client: OrderClient,
     symbol_key: str,
     to_ems_stream: tractor.MsgStream,
@@ -242,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:
 
@@ -281,8 +288,11 @@ async def open_ems(
             client._ems_stream = trades_stream
 
             # start sync code order msg delivery task
-            async with trio.open_nursery() as n:
+            async with (
-                n.start_soon(
+                collapse_eg(),
+                trio.open_nursery() as tn,
+            ):
+                tn.start_soon(
                     relay_orders_from_sync_code,
                     client,
                     fqme,
@@ -298,4 +308,4 @@ async def open_ems(
                 )
 
                 # stop the sync-msg-relay task on exit.
-                n.cancel_scope.cancel()
+                tn.cancel_scope.cancel()

piker/clearing/_ems.py

@@ -42,6 +42,7 @@ from bidict import bidict
 import trio
 from trio_typing import TaskStatus
 import tractor
+from tractor import trionics
 
 from ._util import (
     log,  # sub-sys logger
@@ -76,7 +77,6 @@ if TYPE_CHECKING:
 
 # TODO: numba all of this
 def mk_check(
-
     trigger_price: float,
     known_last: float,
     action: str,
@@ -162,7 +162,7 @@ async def clear_dark_triggers(
 
     router: Router,
     brokerd_orders_stream: tractor.MsgStream,
-    quote_stream: tractor.ReceiveMsgStream,  # noqa
+    quote_stream: tractor.MsgStream,
     broker: str,
     fqme: str,
 
@@ -178,6 +178,7 @@ async def clear_dark_triggers(
     '''
     # XXX: optimize this for speed!
     # TODO:
+    # - port to the new ringbuf stuff in `tractor.ipc`!
     # - numba all this!
     # - this stream may eventually contain multiple symbols
     quote_stream._raise_on_lag = False
@@ -387,6 +388,7 @@ async def open_brokerd_dialog(
     for ep_name in [
         'open_trade_dialog',  # probably final name?
         'trades_dialogue',  # legacy
+        # ^!TODO, rm this since all backends ported no ?!?
     ]:
         trades_endpoint = getattr(
             brokermod,
@@ -500,7 +502,7 @@ class Router(Struct):
 
     '''
     # setup at actor spawn time
-    nursery: trio.Nursery
+    _tn: trio.Nursery
 
     # broker to book map
     books: dict[str, DarkBook] = {}
@@ -653,7 +655,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,
@@ -666,7 +672,7 @@ class Router(Struct):
                 # dark book clearing loop, also lives with parent
                 # daemon to allow dark order clearing while no
                 # client is connected.
-                self.nursery.start_soon(
+                self._tn.start_soon(
                     clear_dark_triggers,
                     self,
                     relay.brokerd_stream,
@@ -689,7 +695,7 @@ class Router(Struct):
 
                 # spawn a ``brokerd`` order control dialog stream
                 # that syncs lifetime with the parent `emsd` daemon.
-                self.nursery.start_soon(
+                self._tn.start_soon(
                     translate_and_relay_brokerd_events,
                     broker,
                     relay.brokerd_stream,
@@ -716,7 +722,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
@@ -763,10 +769,12 @@ async def _setup_persistent_emsd(
 
     global _router
 
-    # open a root "service nursery" for the ``emsd`` actor
+    # open a root "service task-nursery" for the `emsd`-actor
-    async with trio.open_nursery() as service_nursery:
+    async with (
-
+        trionics.collapse_eg(),
-        _router = Router(nursery=service_nursery)
+        trio.open_nursery() as tn
+    ):
+        _router = Router(_tn=tn)
 
         # TODO: send back the full set of persistent
         # orders/execs?
@@ -1010,14 +1018,28 @@ async def translate_and_relay_brokerd_events(
                 status_msg.brokerd_msg = msg
                 status_msg.src = msg.broker_details['name']
 
-                await router.client_broadcast(
+                if not status_msg.req:
-                    status_msg.req.symbol,
+                    # likely some order change state?
-                    status_msg,
+                    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!')
+                    log.info(
-                    status_msg = book._active.pop(oid)
+                        f'Execution is complete!\n'
+                        f'oid: {oid!r}\n'
+                    )
+                    status_msg = book._active.pop(oid, None)
+                    if status_msg is None:
+                        log.warning(
+                            f'Order was already cleared from book ??\n'
+                            f'oid: {oid!r}\n'
+                            f'\n'
+                            f'Maybe the order cancelled before submitted ??\n'
+                        )
 
                 elif status == 'canceled':
                     log.cancel(f'Cancellation for {oid} is complete!')
@@ -1182,12 +1204,16 @@ async def process_client_order_cmds(
     submitting live orders immediately if requested by the client.
 
     '''
-    # cmd: dict
+    # TODO, only allow `msgspec.Struct` form!
+    cmd: dict
     async for cmd in client_order_stream:
-        log.info(f'Received order cmd:\n{pformat(cmd)}')
+        log.info(
+            f'Received order cmd:\n'
+            f'{pformat(cmd)}\n'
+        )
 
         # CAWT DAMN we need struct support!
-        oid = str(cmd['oid'])
+        oid: str = str(cmd['oid'])
 
         # register this stream as an active order dialog (msg flow) for
         # this order id such that translated message from the brokerd
@@ -1293,7 +1319,7 @@ async def process_client_order_cmds(
             case {
                 'oid': oid,
                 'symbol': fqme,
-                'price': trigger_price,
+                'price': price,
                 'size': size,
                 'action': ('buy' | 'sell') as action,
                 'exec_mode': ('live' | 'paper'),
@@ -1325,7 +1351,7 @@ async def process_client_order_cmds(
 
                     symbol=sym,
                     action=action,
-                    price=trigger_price,
+                    price=price,
                     size=size,
                     account=req.account,
                 )
@@ -1347,7 +1373,11 @@ async def process_client_order_cmds(
                 # (``translate_and_relay_brokerd_events()`` above) will
                 # handle relaying the ems side responses back to
                 # the client/cmd sender from this request
-                log.info(f'Sending live order to {broker}:\n{pformat(msg)}')
+                log.info(
+                    f'Sending live order to {broker}:\n'
+                    f'{pformat(msg)}'
+                )
+
                 await brokerd_order_stream.send(msg)
 
                 # an immediate response should be ``BrokerdOrderAck``
@@ -1363,7 +1393,7 @@ async def process_client_order_cmds(
             case {
                 'oid': oid,
                 'symbol': fqme,
-                'price': trigger_price,
+                'price': price,
                 'size': size,
                 'exec_mode': exec_mode,
                 'action': action,
@@ -1391,7 +1421,12 @@ async def process_client_order_cmds(
                 if isnan(last):
                     last = flume.rt_shm.array[-1]['close']
 
-                pred = mk_check(trigger_price, last, action)
+                trigger_price: float = float(price)
+                pred = mk_check(
+                    trigger_price,
+                    last,
+                    action,
+                )
 
                 # NOTE: for dark orders currently we submit
                 # the triggered live order at a price 5 ticks
@@ -1498,7 +1533,7 @@ async def maybe_open_trade_relays(
         loglevel: str = 'info',
     ):
 
-        fqme, relay, feed, client_ready = await _router.nursery.start(
+        fqme, relay, feed, client_ready = await _router._tn.start(
             _router.open_trade_relays,
             fqme,
             exec_mode,
@@ -1528,19 +1563,18 @@ async def maybe_open_trade_relays(
 
 @tractor.context
 async def _emsd_main(
-    ctx: tractor.Context,
+    ctx: tractor.Context,   # becomes `ems_ctx` below
     fqme: str,
     exec_mode: str,  # ('paper', 'live')
-    loglevel: str | None = None,
+    loglevel: str|None = None,
 
-) -> tuple[
+) -> tuple[  # `ctx.started()` value!
-    dict[
+    dict[  # positions
-        # brokername, acctid
+        tuple[str, str],  # brokername, acctid
-        tuple[str, str],
         list[BrokerdPosition],
     ],
-    list[str],
+    list[str],  # accounts
-    dict[str, Status],
+    dict[str, Status],  # dialogs
 ]:
     '''
     EMS (sub)actor entrypoint providing the execution management

piker/clearing/_messages.py

@@ -19,6 +19,7 @@ Clearing sub-system message and protocols.
 
 """
 from __future__ import annotations
+from decimal import Decimal
 from typing import (
     Literal,
 )
@@ -71,7 +72,15 @@ class Order(Struct):
     symbol: str  # | MktPair
     account: str  # should we set a default as '' ?
 
-    price: float
+    # https://docs.python.org/3/library/decimal.html#decimal-objects
+    #
+    # ?TODO? decimal usage throughout?
+    # -[ ] possibly leverage the `Encoder(decimal_format='number')`
+    #  bit?
+    # |_https://jcristharif.com/msgspec/supported-types.html#decimal
+    # -[ ] should we also use it for .size?
+    #
+    price: Decimal
     size: float  # -ve is "sell", +ve is "buy"
 
     brokers: list[str] = []
@@ -178,7 +187,7 @@ class BrokerdOrder(Struct):
     time_ns: int
 
     symbol: str  # fqme
-    price: float
+    price: Decimal
     size: float
 
     # TODO: if we instead rely on a +ve/-ve size to determine
@@ -292,6 +301,9 @@ class BrokerdError(Struct):
 
 # TODO: yeah, so we REALLY need to completely deprecate
 # this and use the `.accounting.Position` msg-type instead..
+# -[ ] an alternative might be to add a `Position.summary() ->
+#   `PositionSummary`-msg that we generate since `Position` has a lot
+#   of fields by default we likely don't want to send over the wire?
 class BrokerdPosition(Struct):
     '''
     Position update event from brokerd.
@@ -304,3 +316,4 @@ class BrokerdPosition(Struct):
     avg_price: float
     currency: str = ''
     name: str = 'position'
+    bs_mktid: str|int|None = None

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,
@@ -508,7 +510,7 @@ async def handle_order_requests(
                 reqid = await client.submit_limit(
                     oid=order.oid,
                     symbol=f'{order.symbol}.{client.broker}',
-                    price=order.price,
+                    price=float(order.price),
                     action=order.action,
                     size=order.size,
                     # XXX: by default 0 tells ``ib_insync`` methods that
@@ -653,6 +655,7 @@ async def open_trade_dialog(
                 # in) use manually constructed table from calling
                 # the `.get_mkt_info()` provider EP above.
                 _mktmap_table=mkt_by_fqme,
+                only_require=list(mkt_by_fqme),
             )
 
             pp_msgs: list[BrokerdPosition] = []

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/cli/__init__.py

@@ -134,86 +134,65 @@ def pikerd(
     Spawn the piker broker-daemon.
 
     '''
-    from tractor.devx import maybe_open_crash_handler
+    # from tractor.devx import maybe_open_crash_handler
-    with maybe_open_crash_handler(pdb=pdb):
+    # with maybe_open_crash_handler(pdb=False):
-        log = get_console_log(loglevel, name='cli')
+    log = get_console_log(loglevel, name='cli')
 
-        if pdb:
+    if pdb:
-            log.warning((
+        log.warning((
-                "\n"
+            "\n"
-                "!!! YOU HAVE ENABLED DAEMON DEBUG MODE !!!\n"
+            "!!! YOU HAVE ENABLED DAEMON DEBUG MODE !!!\n"
-                "When a `piker` daemon crashes it will block the "
+            "When a `piker` daemon crashes it will block the "
-                "task-thread until resumed from console!\n"
+            "task-thread until resumed from console!\n"
-                "\n"
+            "\n"
+        ))
+
+    # service-actor registry endpoint socket-address set
+    regaddrs: list[tuple[str, int]] = []
+
+    conf, _ = config.load(
+        conf_name='conf',
+    )
+    network: dict = conf.get('network')
+    if (
+        network is None
+        and not maddr
+    ):
+        regaddrs = [(
+            _default_registry_host,
+            _default_registry_port,
+        )]
+
+    else:
+        eps: dict = load_trans_eps(
+            network,
+            maddr,
+        )
+        for layers in eps['pikerd']:
+            regaddrs.append((
+                layers['ipv4']['addr'],
+                layers['tcp']['port'],
             ))
 
-        # service-actor registry endpoint socket-address set
+    from .. import service
-        regaddrs: list[tuple[str, int]] = []
 
-        conf, _ = config.load(
+    async def main():
-            conf_name='conf',
+        service_mngr: service.Services
-        )
+        async with (
-        network: dict = conf.get('network')
+            service.open_pikerd(
-        if (
+                registry_addrs=regaddrs,
-            network is None
+                loglevel=loglevel,
-            and not maddr
+                debug_mode=pdb,
+                # enable_transports=['uds'],
+                enable_transports=['tcp'],
+            ) as service_mngr,
         ):
-            regaddrs = [(
+            assert service_mngr
-                _default_registry_host,
+            # ?TODO? spawn all other sub-actor daemons according to
-                _default_registry_port,
+            # multiaddress endpoint spec defined by user config
-            )]
+            await trio.sleep_forever()
 
-        else:
+    trio.run(main)
-            eps: dict = load_trans_eps(
-                network,
-                maddr,
-            )
-            for layers in eps['pikerd']:
-                regaddrs.append((
-                    layers['ipv4']['addr'],
-                    layers['tcp']['port'],
-                ))
-
-        from .. import service
-
-        async def main():
-            service_mngr: service.Services
-
-            async with (
-                service.open_pikerd(
-                    registry_addrs=regaddrs,
-                    loglevel=loglevel,
-                    debug_mode=pdb,
-
-                ) as service_mngr,  # normally delivers a ``Services`` handle
-
-                # AsyncExitStack() as stack,
-            ):
-                # TODO: spawn all other sub-actor daemons according to
-                # multiaddress endpoint spec defined by user config
-                assert service_mngr
-
-                # if tsdb:
-                #     dname, conf = await stack.enter_async_context(
-                #         service.marketstore.start_ahab_daemon(
-                #             service_mngr,
-                #             loglevel=loglevel,
-                #         )
-                #     )
-                #     log.info(f'TSDB `{dname}` up with conf:\n{conf}')
-
-                # if es:
-                #     dname, conf = await stack.enter_async_context(
-                #         service.elastic.start_ahab_daemon(
-                #             service_mngr,
-                #             loglevel=loglevel,
-                #         )
-                #     )
-                #     log.info(f'DB `{dname}` up with conf:\n{conf}')
-
-                await trio.sleep_forever()
-
-        trio.run(main)
 
 
 @click.group(context_settings=config._context_defaults)
@@ -328,6 +307,10 @@ def services(config, tl, ports):
     if not ports:
         ports = [_default_registry_port]
 
+    addr = tractor._addr.wrap_address(
+        addr=(host, ports[0])
+    )
+
     async def list_services():
         nonlocal host
         async with (
@@ -335,16 +318,18 @@ def services(config, tl, ports):
                 name='service_query',
                 loglevel=config['loglevel'] if tl else None,
             ),
-            tractor.get_arbiter(
+            tractor.get_registry(
-                host=host,
+                addr=addr,
-                port=ports[0]
             ) as portal
         ):
-            registry = await portal.run_from_ns('self', 'get_registry')
+            registry = await portal.run_from_ns(
+                'self',
+                'get_registry',
+            )
             json_d = {}
             for key, socket in registry.items():
-                host, port = socket
+                json_d[key] = f'{socket}'
-                json_d[key] = f'{host}:{port}'
+
             click.echo(f"{colorize_json(json_d)}")
 
     trio.run(list_services)

piker/config.py

@@ -41,10 +41,13 @@ from .log import get_logger
 log = get_logger('broker-config')
 
 
-# XXX NOTE: taken from ``click`` since apparently they have some
+# XXX NOTE: taken from `click`
-# super weirdness with sigint and sudo..no clue
+# |_https://github.com/pallets/click/blob/main/src/click/utils.py#L449
-# we're probably going to slowly just modify it to our own version over
+#
-# time..
+# (since apparently they have some super weirdness with SIGINT and
+# sudo.. no clue we're probably going to slowly just modify it to our
+# own version over time..)
+#
 def get_app_dir(
     app_name: str,
     roaming: bool = True,
@@ -261,7 +264,7 @@ def load(
         MutableMapping,
     ] = tomllib.loads,
 
-    touch_if_dne: bool = False,
+    touch_if_dne: bool = True,
 
     **tomlkws,
 
@@ -270,7 +273,7 @@ def load(
     Load config file by name.
 
     If desired config is not in the top level piker-user config path then
-    pass the ``path: Path`` explicitly.
+    pass the `path: Path` explicitly.
 
     '''
     # create the $HOME/.config/piker dir if dne
@@ -285,7 +288,8 @@ def load(
 
     if (
         not path.is_file()
-        and touch_if_dne
+        and
+        touch_if_dne
     ):
         # only do a template if no path provided,
         # just touch an empty file with same name.

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()
+        # NOTE, for debugging pub-sub issues
-        log.debug(
+        # task = trio.lowlevel.current_task()
-            f'SUBS {self.subscribers}\n'
+        # log.debug(
-            f'PAIR {pair}\n'
+        #     f'AlL-SUBS@{period_s!r}: {self.subscribers}\n'
-            f'TASK: {task}: {id(task)}\n'
+        #     f'PAIR: {pair}\n'
-            f'broadcasting {period_s} -> {last_ts}\n'
+        #     f'TASK: {task}: {id(task)}\n'
-            # f'consumers: {subs}'
+        #     f'broadcasting {period_s} -> {last_ts}\n'
-        )
+        #     f'consumers: {subs}'
+        # )
         borked: set[MsgStream] = set()
         sent: set[MsgStream] = set()
         while True:
@@ -282,12 +289,11 @@ class Sampler:
                         await stream.send(msg)
                         sent.add(stream)
 
-                    except (
+                    except self.bcast_errors as err:
-                        trio.BrokenResourceError,
-                        trio.ClosedResourceError
-                    ):
                         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:
@@ -394,7 +400,8 @@ async def register_with_sampler(
                 finally:
                     if (
                         sub_for_broadcasts
-                        and subs
+                        and
+                        subs
                     ):
                         try:
                             subs.remove(stream)
@@ -561,8 +568,7 @@ async def open_sample_stream(
 
 
 async def sample_and_broadcast(
-
+    bus: _FeedsBus,
-    bus: _FeedsBus,  # noqa
     rt_shm: ShmArray,
     hist_shm: ShmArray,
     quote_stream: trio.abc.ReceiveChannel,
@@ -582,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
@@ -659,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
@@ -697,7 +740,7 @@ async def sample_and_broadcast(
 
                                 log.warning(
                                     f'Feed OVERRUN {sub_key}'
-                                    '@{bus.brokername} -> \n'
+                                    f'@{bus.brokername} -> \n'
                                     f'feed @ {chan.uid}\n'
                                     f'throttle = {throttle} Hz'
                                 )
@@ -728,18 +771,14 @@ async def sample_and_broadcast(
                         if lags > 10:
                             await tractor.pause()
 
-                except (
+                except Sampler.bcast_errors as ipc_err:
-                    trio.BrokenResourceError,
-                    trio.ClosedResourceError,
-                    trio.EndOfChannel,
-                ):
                     ctx: Context = ipc._ctx
                     chan: Channel = ctx.chan
                     if ctx:
                         log.warning(
-                            'Dropped `brokerd`-quotes-feed connection:\n'
+                            f'Dropped `brokerd`-feed for {broker_symbol!r} due to,\n'
-                            f'{broker_symbol}:'
+                            f'x>) {ctx.cid}@{chan.uid}'
-                            f'{ctx.cid}@{chan.uid}'
+                            f'|_{ipc_err!r}\n\n'
                         )
                     if sub.throttle_rate:
                         assert ipc._closed
@@ -756,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:
     '''
@@ -779,13 +817,16 @@ async def uniform_rate_send(
     https://gist.github.com/njsmith/7ea44ec07e901cb78ebe1dd8dd846cb9
 
     '''
-    # TODO: compute the approx overhead latency per cycle
+    # ?TODO? dynamically compute the **actual** approx overhead latency per cycle
-    left_to_sleep = throttle_period = 1/rate - 0.000616
+    # 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()
+    last_send: float = time.time()
-    diff = 0
+    diff: float = 0
 
     task_status.started()
     ticks_by_type: dict[
@@ -796,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:
@@ -872,7 +919,9 @@ 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
@@ -883,19 +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,
-        ):
+        ) + Sampler.bcast_errors as ipc_err:
-            # if the feed consumer goes down then drop
+            match ipc_err:
-            # out of this rate limiter
+                case trio.EndOfChannel():
-            log.warning(f'{stream} closed')
+                    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/data/_symcache.py

@@ -31,6 +31,7 @@ from pathlib import Path
 from pprint import pformat
 from typing import (
     Any,
+    Callable,
     Sequence,
     Hashable,
     TYPE_CHECKING,
@@ -56,7 +57,7 @@ from piker.brokers import (
 )
 
 if TYPE_CHECKING:
-    from ..accounting import (
+    from piker.accounting import (
         Asset,
         MktPair,
     )
@@ -90,6 +91,18 @@ class SymbologyCache(Struct):
     # provided by the backend pkg.
     mktmaps: dict[str, MktPair] = field(default_factory=dict)
 
+    def pformat(self) -> str:
+        return (
+            f'<{type(self).__name__}(\n'
+            f' .mod: {self.mod!r}\n'
+            f' .assets: {len(self.assets)!r}\n'
+            f' .pairs: {len(self.pairs)!r}\n'
+            f' .mktmaps: {len(self.mktmaps)!r}\n'
+            f')>'
+        )
+
+    __repr__ = pformat
+
     def write_config(self) -> None:
 
         # put the backend's pair-struct type ref at the top
@@ -149,57 +162,68 @@ class SymbologyCache(Struct):
                     'Implement `Client.get_assets()`!'
                 )
 
-            if get_mkt_pairs := getattr(client, 'get_mkt_pairs', None):
+            get_mkt_pairs: Callable|None = getattr(
-
+                client,
-                pairs: dict[str, Struct] = await get_mkt_pairs()
+                'get_mkt_pairs',
-                for bs_fqme, pair in pairs.items():
+                None,
-
+            )
-                    # NOTE: every backend defined pair should
+            if not get_mkt_pairs:
-                    # declare it's ns path for roundtrip
-                    # serialization lookup.
-                    if not getattr(pair, 'ns_path', None):
-                        raise TypeError(
-                            f'Pair-struct for {self.mod.name} MUST define a '
-                            '`.ns_path: str`!\n'
-                            f'{pair}'
-                        )
-
-                    entry = await self.mod.get_mkt_info(pair.bs_fqme)
-                    if not entry:
-                        continue
-
-                    mkt: MktPair
-                    pair: Struct
-                    mkt, _pair = entry
-                    assert _pair is pair, (
-                        f'`{self.mod.name}` backend probably has a '
-                        'keying-symmetry problem between the pair-`Struct` '
-                        'returned from `Client.get_mkt_pairs()`and the '
-                        'module level endpoint: `.get_mkt_info()`\n\n'
-                        "Here's the struct diff:\n"
-                        f'{_pair - pair}'
-                    )
-                    # NOTE XXX: this means backends MUST implement
-                    # a `Struct.bs_mktid: str` field to provide
-                    # a native-keyed map to their own symbol
-                    # set(s).
-                    self.pairs[pair.bs_mktid] = pair
-
-                    # NOTE: `MktPair`s are keyed here using piker's
-                    # internal FQME schema so that search,
-                    # accounting and feed init can be accomplished
-                    # a sane, uniform, normalized basis.
-                    self.mktmaps[mkt.fqme] = mkt
-
-                self.pair_ns_path: str = tractor.msg.NamespacePath.from_ref(
-                    pair,
-                )
-
-            else:
                 log.warning(
                     'No symbology cache `Pair` support for `{provider}`..\n'
                     'Implement `Client.get_mkt_pairs()`!'
                 )
+                return self
+
+            pairs: dict[str, Struct] = await get_mkt_pairs()
+            if not pairs:
+                log.warning(
+                    'No pairs from intial {provider!r} sym-cache request?\n\n'
+                    '`Client.get_mkt_pairs()` -> {pairs!r} ?'
+                )
+                return self
+
+            for bs_fqme, pair in pairs.items():
+                if not getattr(pair, 'ns_path', None):
+                    # XXX: every backend defined pair must declare
+                    # a `.ns_path: tractor.NamespacePath` to enable
+                    # roundtrip serialization lookup from a local
+                    # cache file.
+                    raise TypeError(
+                        f'Pair-struct for {self.mod.name} MUST define a '
+                        '`.ns_path: str`!\n\n'
+                        f'{pair!r}'
+                    )
+
+                entry = await self.mod.get_mkt_info(pair.bs_fqme)
+                if not entry:
+                    continue
+
+                mkt: MktPair
+                pair: Struct
+                mkt, _pair = entry
+                assert _pair is pair, (
+                    f'`{self.mod.name}` backend probably has a '
+                    'keying-symmetry problem between the pair-`Struct` '
+                    'returned from `Client.get_mkt_pairs()`and the '
+                    'module level endpoint: `.get_mkt_info()`\n\n'
+                    "Here's the struct diff:\n"
+                    f'{_pair - pair}'
+                )
+                # NOTE XXX: this means backends MUST implement
+                # a `Struct.bs_mktid: str` field to provide
+                # a native-keyed map to their own symbol
+                # set(s).
+                self.pairs[pair.bs_mktid] = pair
+
+                # NOTE: `MktPair`s are keyed here using piker's
+                # internal FQME schema so that search,
+                # accounting and feed init can be accomplished
+                # a sane, uniform, normalized basis.
+                self.mktmaps[mkt.fqme] = mkt
+
+            self.pair_ns_path: str = tractor.msg.NamespacePath.from_ref(
+                pair,
+            )
 
         return self
 

piker/data/_web_bs.py

@@ -27,7 +27,6 @@ from functools import partial
 from types import ModuleType
 from typing import (
     Any,
-    Optional,
     Callable,
     AsyncContextManager,
     AsyncGenerator,
@@ -35,6 +34,7 @@ from typing import (
 )
 import json
 
+import tractor
 import trio
 from trio_typing import TaskStatus
 from trio_websocket import (
@@ -167,7 +167,7 @@ async def _reconnect_forever(
 
     async def proxy_msgs(
         ws: WebSocketConnection,
-        pcs: trio.CancelScope,  # parent cancel scope
+        rent_cs: trio.CancelScope,  # parent cancel scope
     ):
         '''
         Receive (under `timeout` deadline) all msgs from from underlying
@@ -192,7 +192,7 @@ async def _reconnect_forever(
                         f'{url} connection bail with:'
                     )
                     await trio.sleep(0.5)
-                    pcs.cancel()
+                    rent_cs.cancel()
 
                     # go back to reonnect loop in parent task
                     return
@@ -204,7 +204,7 @@ async def _reconnect_forever(
                         f'{src_mod}\n'
                         'WS feed seems down and slow af.. reconnecting\n'
                     )
-                    pcs.cancel()
+                    rent_cs.cancel()
 
                     # go back to reonnect loop in parent task
                     return
@@ -228,7 +228,12 @@ async def _reconnect_forever(
     nobsws._connected = trio.Event()
     task_status.started()
 
-    while not snd._closed:
+    mc_state: trio._channel.MemoryChannelState = snd._state
+    while (
+        mc_state.open_receive_channels > 0
+        and
+        mc_state.open_send_channels > 0
+    ):
         log.info(
             f'{src_mod}\n'
             f'{url} trying (RE)CONNECT'
@@ -237,10 +242,11 @@ async def _reconnect_forever(
         ws: WebSocketConnection
         try:
             async with (
-                trio.open_nursery() as n,
                 open_websocket_url(url) as ws,
+                tractor.trionics.collapse_eg(),
+                trio.open_nursery() as tn,
             ):
-                cs = nobsws._cs = n.cancel_scope
+                cs = nobsws._cs = tn.cancel_scope
                 nobsws._ws = ws
                 log.info(
                     f'{src_mod}\n'
@@ -248,7 +254,7 @@ async def _reconnect_forever(
                 )
 
                 # begin relay loop to forward msgs
-                n.start_soon(
+                tn.start_soon(
                     proxy_msgs,
                     ws,
                     cs,
@@ -262,7 +268,7 @@ async def _reconnect_forever(
 
                     # TODO: should we return an explicit sub-cs
                     # from this fixture task?
-                    await n.start(
+                    await tn.start(
                         open_fixture,
                         fixture,
                         nobsws,
@@ -272,11 +278,23 @@ async def _reconnect_forever(
                 # to let tasks run **inside** the ws open block above.
                 nobsws._connected.set()
                 await trio.sleep_forever()
-        except HandshakeError:
+
+        except (
+            HandshakeError,
+            ConnectionRejected,
+        ):
             log.exception('Retrying connection')
+            await trio.sleep(0.5)  # throttle
 
-        # ws & nursery block ends
+        except BaseException as _berr:
+            berr = _berr
+            log.exception(
+                'Reconnect-attempt failed ??\n'
+            )
+            await trio.sleep(0.2)  # throttle
+            raise berr
 
+        #|_ws & nursery block ends
         nobsws._connected = trio.Event()
         if cs.cancelled_caught:
             log.cancel(
@@ -324,21 +342,25 @@ async def open_autorecon_ws(
     connetivity errors, or some user defined recv timeout.
 
     You can provide a ``fixture`` async-context-manager which will be
-    entered/exitted around each connection reset; eg. for (re)requesting
+    entered/exitted around each connection reset; eg. for
-    subscriptions without requiring streaming setup code to rerun.
+    (re)requesting subscriptions without requiring streaming setup
+    code to rerun.
 
     '''
     snd: trio.MemorySendChannel
     rcv: trio.MemoryReceiveChannel
     snd, rcv = trio.open_memory_channel(616)
 
-    async with trio.open_nursery() as n:
+    async with (
+        tractor.trionics.collapse_eg(),
+        trio.open_nursery() as tn
+    ):
         nobsws = NoBsWs(
             url,
             rcv,
             msg_recv_timeout=msg_recv_timeout,
         )
-        await n.start(
+        await tn.start(
             partial(
                 _reconnect_forever,
                 url,
@@ -351,11 +373,10 @@ async def open_autorecon_ws(
         await nobsws._connected.wait()
         assert nobsws._cs
         assert nobsws.connected()
-
         try:
             yield nobsws
         finally:
-            n.cancel_scope.cancel()
+            tn.cancel_scope.cancel()
 
 
 '''
@@ -368,8 +389,8 @@ of msgs over a `NoBsWs`.
 class JSONRPCResult(Struct):
     id: int
     jsonrpc: str = '2.0'
-    result: Optional[dict] = None
+    result: dict|None = None
-    error: Optional[dict] = None
+    error: dict|None = None
 
 
 @acm

piker/data/feed.py

@@ -39,6 +39,7 @@ from typing import (
     AsyncContextManager,
     Awaitable,
     Sequence,
+    TYPE_CHECKING,
 )
 
 import trio
@@ -75,6 +76,10 @@ from ._sampling import (
     uniform_rate_send,
 )
 
+if TYPE_CHECKING:
+    from tractor._addr import Address
+    from tractor.msg.types import Aid
+
 
 class Sub(Struct, frozen=True):
     '''
@@ -352,7 +357,9 @@ async def allocate_persistent_feed(
 
     # yield back control to starting nursery once we receive either
     # some history or a real-time quote.
-    log.info(f'loading OHLCV history: {fqme}')
+    log.info(
+        f'loading OHLCV history: {fqme!r}\n'
+    )
     await some_data_ready.wait()
 
     flume = Flume(
@@ -723,7 +730,10 @@ class Feed(Struct):
                 async for msg in stream:
                     await tx.send(msg)
 
-        async with trio.open_nursery() as nurse:
+        async with (
+            tractor.trionics.collapse_eg(),
+            trio.open_nursery() as nurse
+        ):
             # spawn a relay task for each stream so that they all
             # multiplex to a common channel.
             for brokername in mods:
@@ -786,7 +796,6 @@ async def install_brokerd_search(
 
 @acm
 async def maybe_open_feed(
-
     fqmes: list[str],
     loglevel: str | None = None,
 
@@ -840,13 +849,12 @@ async def maybe_open_feed(
 
 @acm
 async def open_feed(
-
     fqmes: list[str],
 
-    loglevel: str | None = None,
+    loglevel: str|None = None,
     allow_overruns: bool = True,
     start_stream: bool = True,
-    tick_throttle: float | None = None,  # Hz
+    tick_throttle: float|None = None,  # Hz
 
     allow_remote_ctl_ui: bool = False,
 
@@ -899,19 +907,19 @@ async def open_feed(
             feed.portals[brokermod] = portal
 
             # fill out "status info" that the UI can show
-            host, port = portal.channel.raddr
+            chan: tractor.Channel = portal.chan
-            if host == '127.0.0.1':
+            raddr: Address = chan.raddr
-                host = 'localhost'
+            aid: Aid = chan.aid
-
+            # TAG_feed_status_update
             feed.status.update({
-                'actor_name': portal.channel.uid[0],
+                'actor_id': aid,
-                'host': host,
+                'actor_short_id': f'{aid.name}@{aid.pid}',
-                'port': port,
+                'ipc': chan.raddr.proto_key,
+                'ipc_addr': raddr,
                 'hist_shm': 'NA',
                 'rt_shm': 'NA',
-                'throttle_rate': tick_throttle,
+                'throttle_hz': tick_throttle,
             })
-            # feed.status.update(init_msg.pop('status', {}))
 
             # (allocate and) connect to any feed bus for this broker
             bus_ctxs.append(

piker/data/flows.py

@@ -36,10 +36,10 @@ from ._sharedmem import (
     ShmArray,
     _Token,
 )
+from piker.accounting import MktPair
 
 if TYPE_CHECKING:
-    from ..accounting import MktPair
+    from piker.data.feed import Feed
-    from .feed import Feed
 
 
 class Flume(Struct):
@@ -82,7 +82,7 @@ class Flume(Struct):
 
     # TODO: do we need this really if we can pull the `Portal` from
     # ``tractor``'s internals?
-    feed: Feed | None = None
+    feed: Feed|None = None
 
     @property
     def rt_shm(self) -> ShmArray:

piker/data/validate.py

@@ -113,9 +113,9 @@ def validate_backend(
             )
             if ep is None:
                 log.warning(
-                    f'Provider backend {mod.name} is missing '
+                    f'Provider backend {mod.name!r} is missing '
-                    f'{daemon_name} support :(\n'
+                    f'{daemon_name!r} support?\n'
-                    f'The following endpoint is missing: {name}'
+                    f'|_module endpoint-func missing: {name!r}\n'
                 )
 
     inits: list[

piker/fsp/_engine.py

@@ -498,6 +498,7 @@ async def cascade(
 
         func_name: str = func.__name__
         async with (
+            tractor.trionics.collapse_eg(),  # avoid multi-taskc tb in console
             trio.open_nursery() as tn,
         ):
             # TODO: might be better to just make a "restart" method where

piker/log.py

@@ -19,6 +19,10 @@ Log like a forester!
 """
 import logging
 import json
+import reprlib
+from typing import (
+    Callable,
+)
 
 import tractor
 from pygments import (
@@ -84,3 +88,29 @@ def colorize_json(
         # likeable styles: algol_nu, tango, monokai
         formatters.TerminalTrueColorFormatter(style=style)
     )
+
+
+# TODO, eventually defer to the version in `modden` once
+# it becomes a dep!
+def mk_repr(
+    **repr_kws,
+) -> Callable[[str], str]:
+    '''
+    Allocate and deliver a `repr.Repr` instance with provided input
+    settings using the std-lib's `reprlib` mod,
+     * https://docs.python.org/3/library/reprlib.html
+
+    ------ Ex. ------
+    An up to 6-layer-nested `dict` as multi-line:
+    - https://stackoverflow.com/a/79102479
+    - https://docs.python.org/3/library/reprlib.html#reprlib.Repr.maxlevel
+
+    '''
+    def_kws: dict[str, int] = dict(
+        indent=2,
+        maxlevel=6,  # recursion levels
+        maxstring=66,  # match editor line-len limit
+    )
+    def_kws |= repr_kws
+    reprr = reprlib.Repr(**def_kws)
+    return reprr.repr

piker/service/_actor_runtime.py

@@ -107,17 +107,22 @@ async def open_piker_runtime(
         async with (
             tractor.open_root_actor(
 
-                # passed through to ``open_root_actor``
+                # passed through to `open_root_actor`
                 registry_addrs=registry_addrs,
                 name=name,
+                start_method=start_method,
                 loglevel=loglevel,
                 debug_mode=debug_mode,
-                start_method=start_method,
+
+                # XXX NOTE MEMBER DAT der's a perf hit yo!!
+                # https://greenback.readthedocs.io/en/latest/principle.html#performance
+                maybe_enable_greenback=True,
 
                 # TODO: eventually we should be able to avoid
                 # having the root have more then permissions to
                 # spawn other specialized daemons I think?
                 enable_modules=enable_modules,
+                hide_tb=False,
 
                 **tractor_kwargs,
             ) as actor,
@@ -200,7 +205,8 @@ async def open_pikerd(
             reg_addrs,
         ),
         tractor.open_nursery() as actor_nursery,
-        trio.open_nursery() as service_nursery,
+        tractor.trionics.collapse_eg(),
+        trio.open_nursery() as service_tn,
     ):
         for addr in reg_addrs:
             if addr not in root_actor.accept_addrs:
@@ -211,7 +217,7 @@ async def open_pikerd(
 
         # assign globally for future daemon/task creation
         Services.actor_n = actor_nursery
-        Services.service_n = service_nursery
+        Services.service_n = service_tn
         Services.debug_mode = debug_mode
 
         try:
@@ -221,7 +227,7 @@ async def open_pikerd(
             # TODO: is this more clever/efficient?
             # if 'samplerd' in Services.service_tasks:
             #     await Services.cancel_service('samplerd')
-            service_nursery.cancel_scope.cancel()
+            service_tn.cancel_scope.cancel()
 
 
 # TODO: do we even need this?
@@ -256,7 +262,10 @@ async def maybe_open_pikerd(
     loglevel: str | None = None,
     **kwargs,
 
-) -> tractor._portal.Portal | ClassVar[Services]:
+) -> (
+    tractor._portal.Portal
+    |ClassVar[Services]
+):
     '''
     If no ``pikerd`` daemon-root-actor can be found start it and
     yield up (we should probably figure out returning a portal to self
@@ -281,10 +290,11 @@ async def maybe_open_pikerd(
 
     registry_addrs: list[tuple[str, int]] = (
         registry_addrs
-        or [_default_reg_addr]
+        or
+        [_default_reg_addr]
     )
 
-    pikerd_portal: tractor.Portal | None
+    pikerd_portal: tractor.Portal|None
     async with (
         open_piker_runtime(
             name=query_name,

piker/service/_daemon.py

@@ -28,6 +28,7 @@ from contextlib import (
 )
 
 import tractor
+from trio.lowlevel import current_task
 
 from ._util import (
     log,  # sub-sys logger
@@ -70,69 +71,84 @@ async def maybe_spawn_daemon(
     lock = Services.locks[service_name]
     await lock.acquire()
 
-    async with find_service(
+    try:
-        service_name,
+        async with find_service(
-        registry_addrs=[('127.0.0.1', 6116)],
+            service_name,
-    ) as portal:
+            registry_addrs=[('127.0.0.1', 6116)],
-        if portal is not None:
+        ) as portal:
-            lock.release()
+            if portal is not None:
-            yield portal
+                lock.release()
-            return
+                yield portal
+                return
 
-    log.warning(
+        log.warning(
-        f"Couldn't find any existing {service_name}\n"
+            f"Couldn't find any existing {service_name}\n"
-        'Attempting to spawn new daemon-service..'
+            'Attempting to spawn new daemon-service..'
-    )
+        )
 
-    # ask root ``pikerd`` daemon to spawn the daemon we need if
+        # ask root ``pikerd`` daemon to spawn the daemon we need if
-    # pikerd is not live we now become the root of the
+        # pikerd is not live we now become the root of the
-    # process tree
+        # process tree
-    async with maybe_open_pikerd(
+        async with maybe_open_pikerd(
-        loglevel=loglevel,
+            loglevel=loglevel,
-        **pikerd_kwargs,
+            **pikerd_kwargs,
 
-    ) as pikerd_portal:
+        ) as pikerd_portal:
 
-        # we are the root and thus are `pikerd`
+            # we are the root and thus are `pikerd`
-        # so spawn the target service directly by calling
+            # so spawn the target service directly by calling
-        # the provided target routine.
+            # the provided target routine.
-        # XXX: this assumes that the target is well formed and will
+            # XXX: this assumes that the target is well formed and will
-        # do the right things to setup both a sub-actor **and** call
+            # do the right things to setup both a sub-actor **and** call
-        # the ``_Services`` api from above to start the top level
+            # the ``_Services`` api from above to start the top level
-        # service task for that actor.
+            # service task for that actor.
-        started: bool
+            started: bool
-        if pikerd_portal is None:
+            if pikerd_portal is None:
-            started = await service_task_target(
+                started = await service_task_target(
-                loglevel=loglevel,
+                    loglevel=loglevel,
-                **spawn_args,
+                    **spawn_args,
+                )
+
+            else:
+                # request a remote `pikerd` (service manager) to start the
+                # target daemon-task, the target can't return
+                # a non-serializable value since it is expected that service
+                # starting is non-blocking and the target task will persist
+                # running "under" or "within" the `pikerd` actor tree after
+                # the questing client disconnects. in other words this
+                # spawns a persistent daemon actor that continues to live
+                # for the lifespan of whatever the service manager inside
+                # `pikerd` says it should.
+                started = await pikerd_portal.run(
+                    service_task_target,
+                    loglevel=loglevel,
+                    **spawn_args,
+                )
+
+            if started:
+                log.info(f'Service {service_name} started!')
+
+            # block until we can discover (by IPC connection) to the newly
+            # spawned daemon-actor and then deliver the portal to the
+            # caller.
+            async with tractor.wait_for_actor(service_name) as portal:
+                lock.release()
+                yield portal
+                await portal.cancel_actor()
+
+    except BaseException as _err:
+        err = _err
+        if (
+            lock.locked()
+            and
+            lock.statistics().owner is current_task()
+        ):
+            log.exception(
+                f'Releasing stale lock after crash..?'
+                f'{err!r}\n'
             )
-
-        else:
-            # request a remote `pikerd` (service manager) to start the
-            # target daemon-task, the target can't return
-            # a non-serializable value since it is expected that service
-            # starting is non-blocking and the target task will persist
-            # running "under" or "within" the `pikerd` actor tree after
-            # the questing client disconnects. in other words this
-            # spawns a persistent daemon actor that continues to live
-            # for the lifespan of whatever the service manager inside
-            # `pikerd` says it should.
-            started = await pikerd_portal.run(
-                service_task_target,
-                loglevel=loglevel,
-                **spawn_args,
-            )
-
-        if started:
-            log.info(f'Service {service_name} started!')
-
-        # block until we can discover (by IPC connection) to the newly
-        # spawned daemon-actor and then deliver the portal to the
-        # caller.
-        async with tractor.wait_for_actor(service_name) as portal:
             lock.release()
-            yield portal
+            raise err
-            await portal.cancel_actor()
 
 
 async def spawn_emsd(

piker/service/_mngr.py

@@ -109,7 +109,7 @@ class Services:
                         # wait on any context's return value
                         # and any final portal result from the
                         # sub-actor.
-                        ctx_res: Any = await ctx.result()
+                        ctx_res: Any = await ctx.wait_for_result()
 
                         # NOTE: blocks indefinitely until cancelled
                         # either by error from the target context

piker/service/_registry.py

@@ -101,13 +101,15 @@ async def open_registry(
 
     if (
         not tractor.is_root_process()
-        and not Registry.addrs
+        and
+        not Registry.addrs
     ):
         Registry.addrs.extend(actor.reg_addrs)
 
     if (
         ensure_exists
-        and not Registry.addrs
+        and
+        not Registry.addrs
     ):
         raise RuntimeError(
             f"`{uid}` registry should already exist but doesn't?"
@@ -146,7 +148,7 @@ async def find_service(
     | list[Portal]
     | None
 ):
-
+    # try:
     reg_addrs: list[tuple[str, int]]
     async with open_registry(
         addrs=(
@@ -157,22 +159,39 @@ async def find_service(
             or Registry.addrs
         ),
     ) as reg_addrs:
-        log.info(f'Scanning for service `{service_name}`')
 
-        maybe_portals: list[Portal] | Portal | None
+        log.info(
+            f'Scanning for service {service_name!r}'
+        )
 
         # attach to existing daemon by name if possible
+        maybe_portals: list[Portal]|Portal|None
         async with tractor.find_actor(
             service_name,
             registry_addrs=reg_addrs,
             only_first=first_only,  # if set only returns single ref
         ) as maybe_portals:
             if not maybe_portals:
+                # log.info(
+                print(
+                    f'Could NOT find service {service_name!r} -> {maybe_portals!r}'
+                )
                 yield None
                 return
 
+            # log.info(
+            print(
+                f'Found service {service_name!r} -> {maybe_portals}'
+            )
             yield maybe_portals
 
+    # except BaseException as _berr:
+    #     berr = _berr
+    #     log.exception(
+    #         'tractor.find_actor() failed with,\n'
+    #     )
+    #     raise berr
+
 
 async def check_for_service(
     service_name: str,

piker/tsp/__init__.py

@@ -963,7 +963,10 @@ async def tsdb_backfill(
         # concurrently load the provider's most-recent-frame AND any
         # pre-existing tsdb history already saved in `piker` storage.
         dt_eps: list[DateTime, DateTime] = []
-        async with trio.open_nursery() as tn:
+        async with (
+            tractor.trionics.collapse_eg(),
+            trio.open_nursery() as tn
+        ):
             tn.start_soon(
                 push_latest_frame,
                 dt_eps,
@@ -1012,9 +1015,16 @@ async def tsdb_backfill(
                 int,
                 Duration,
             ]|None = config.get('frame_types', None)
+
             if def_frame_durs:
                 def_frame_size: Duration = def_frame_durs[timeframe]
-                assert def_frame_size == calced_frame_size
+
+                if def_frame_size != calced_frame_size:
+                    log.warning(
+                        f'Expected frame size {def_frame_size}\n'
+                        f'Rxed frame {calced_frame_size}\n'
+                    )
+                    # await tractor.pause()
             else:
                 # use what we calced from first frame above.
                 def_frame_size = calced_frame_size
@@ -1043,7 +1053,9 @@ async def tsdb_backfill(
             # if there is a gap to backfill from the first
             # history frame until the last datum loaded from the tsdb
             # continue that now in the background
-            async with trio.open_nursery() as tn:
+            async with trio.open_nursery(
+                strict_exception_groups=False,
+            ) as tn:
 
                 bf_done = await tn.start(
                     partial(
@@ -1308,6 +1320,7 @@ async def manage_history(
         # sampling period) data set since normally differently
         # sampled timeseries can be loaded / process independently
         # ;)
+        tractor.trionics.collapse_eg(),
         trio.open_nursery() as tn,
     ):
         log.info(

piker/tsp/_anal.py

@@ -517,7 +517,7 @@ def with_dts(
 
     '''
     return df.with_columns([
-        pl.col(time_col).shift(1).suffix('_prev'),
+        pl.col(time_col).shift(1).name.suffix('_prev'),
         pl.col(time_col).diff().alias('s_diff'),
         pl.from_epoch(pl.col(time_col)).alias('dt'),
     ]).with_columns([
@@ -623,7 +623,7 @@ def detect_vlm_gaps(
 
 ) -> pl.DataFrame:
 
-    vnull: pl.DataFrame = w_dts.filter(
+    vnull: pl.DataFrame = df.filter(
         pl.col(col) == 0
     )
     return vnull

piker/ui/_app.py

@@ -21,6 +21,7 @@ Main app startup and run.
 from functools import partial
 from types import ModuleType
 
+import tractor
 import trio
 
 from piker.ui.qt import (
@@ -116,6 +117,7 @@ async def _async_main(
         needed_brokermods[brokername] = brokers[brokername]
 
     async with (
+        tractor.trionics.collapse_eg(),
         trio.open_nursery() as root_n,
     ):
         # set root nursery and task stack for spawning other charts/feeds

piker/ui/_chart.py

@@ -33,7 +33,6 @@ import trio
 
 from piker.ui.qt import (
     QtCore,
-    QtWidgets,
     Qt,
     QLineF,
     QFrame,

piker/ui/_display.py

@@ -1445,7 +1445,10 @@ async def display_symbol_data(
         # for pause/resume on mouse interaction
         rt_chart.feed = feed
 
-        async with trio.open_nursery() as ln:
+        async with (
+            tractor.trionics.collapse_eg(),
+            trio.open_nursery() as ln,
+        ):
             # if available load volume related built-in display(s)
             vlm_charts: dict[
                 str,

piker/ui/_event.py

@@ -22,7 +22,10 @@ from contextlib import asynccontextmanager as acm
 from typing import Callable
 
 import trio
-from tractor.trionics import gather_contexts
+from tractor.trionics import (
+    gather_contexts,
+    collapse_eg,
+)
 
 from piker.ui.qt import (
     QtCore,
@@ -207,7 +210,10 @@ async def open_signal_handler(
         async for args in recv:
             await async_handler(*args)
 
-    async with trio.open_nursery() as tn:
+    async with (
+        collapse_eg(),
+        trio.open_nursery() as tn
+    ):
         tn.start_soon(proxy_to_handler)
         async with send:
             yield
@@ -242,6 +248,7 @@ async def open_handlers(
     widget: QWidget
     streams: list[trio.abc.ReceiveChannel]
     async with (
+        collapse_eg(),
         trio.open_nursery() as tn,
         gather_contexts([
             open_event_stream(

piker/ui/_feedstatus.py

@@ -18,10 +18,11 @@
 Feed status and controls widget(s) for embedding in a UI-pane.
 
 """
-
 from __future__ import annotations
-from textwrap import dedent
+from typing import (
-from typing import TYPE_CHECKING
+    Any,
+    TYPE_CHECKING,
+)
 
 # from PyQt5.QtCore import Qt
 
@@ -49,35 +50,55 @@ def mk_feed_label(
     a feed control protocol.
 
     '''
-    status = feed.status
+    status: dict[str, Any] = feed.status
     assert status
 
-    msg = dedent("""
+    # SO tips on ws/nls,
-        actor: **{actor_name}**\n
+    # https://stackoverflow.com/a/15721400
-        |_ @**{host}:{port}**\n
+    ws: str = ' '
-    """)
+    # nl: str = '<br>'  # dun work?
+    actor_info_repr: str = (
+        f')> **{status["actor_short_id"]}**\n'
+        '\n'  # bc md?
+    )
 
-    for key, val in status.items():
+    # fields to select *IN* for display
-        if key in ('host', 'port', 'actor_name'):
+    # (see `.data.feed.open_feed()` status
-            continue
+    #  update -> TAG_feed_status_update)
-        msg += f'\n|_ {key}: **{{{key}}}**\n'
+    for key in [
+        'ipc',
+        'hist_shm',
+        'rt_shm',
+        'throttle_hz',
+    ]:
+        # NOTE, the 2nd key is filled via `.format()` updates.
+        actor_info_repr += (
+            f'\n'  # bc md?
+            f'{ws}|_{key}: **{{{key}}}**\n'
+        )
+        # ^TODO? formatting and content..
+        # -[ ] showing which fqme is "forward" on the
+        #    chart/fsp/order-mode?
+        #  '|_ flows: **{symbols}**\n'
+        #
+        # -[x] why isn't the indent working?
+        #  => markdown, now solved..
 
     feed_label = FormatLabel(
-        fmt_str=msg,
+        fmt_str=actor_info_repr,
-        # |_ streams: **{symbols}**\n
         font=_font.font,
         font_size=_font_small.px_size,
         font_color='default_lightest',
     )
 
+    # ?TODO, remove this?
     # form.vbox.setAlignment(feed_label, Qt.AlignBottom)
     # form.vbox.setAlignment(Qt.AlignBottom)
-    _ = chart.height() - (
+    # _ = chart.height() - (
-        form.height() +
+    #     form.height() +
-        form.fill_bar.height()
+    #     form.fill_bar.height()
-        # feed_label.height()
+    #     # feed_label.height()
-    )
+    # )
 
     feed_label.format(**feed.status)
-
     return feed_label

piker/ui/_fsp.py

@@ -600,6 +600,7 @@ async def open_fsp_admin(
             kwargs=kwargs,
         ) as (cache_hit, cluster_map),
 
+        tractor.trionics.collapse_eg(),
         trio.open_nursery() as tn,
     ):
         if cache_hit:
@@ -613,6 +614,8 @@ async def open_fsp_admin(
         )
         try:
             yield admin
+
+        # ??TODO, does this *need* to be inside a finally?
         finally:
             # terminate all tasks via signals
             for key, entry in admin._registry.items():

piker/ui/_label.py

@@ -285,18 +285,20 @@ class FormatLabel(QLabel):
         font_size: int,
         font_color: str,
 
+        use_md: bool = True,
+
         parent=None,
 
     ) -> None:
 
         super().__init__(parent)
 
-        # by default set the format string verbatim and expect user to
+        # by default set the format string verbatim and expect user
-        # call ``.format()`` later (presumably they'll notice the
+        # to call ``.format()`` later (presumably they'll notice the
         # unformatted content if ``fmt_str`` isn't meant to be
         # unformatted).
         self.fmt_str = fmt_str
-        self.setText(fmt_str)
+        # self.setText(fmt_str)  # ?TODO, why here?
 
         self.setStyleSheet(
             f"""QLabel {{
@@ -306,9 +308,10 @@ class FormatLabel(QLabel):
             """
         )
         self.setFont(_font.font)
-        self.setTextFormat(
+        if use_md:
-            Qt.TextFormat.MarkdownText
+            self.setTextFormat(
-        )
+                Qt.TextFormat.MarkdownText
+            )
         self.setMargin(0)
 
         self.setSizePolicy(
@@ -316,7 +319,10 @@ class FormatLabel(QLabel):
             size_policy.Expanding,
         )
         self.setAlignment(
-            Qt.AlignVCenter | Qt.AlignLeft
+            Qt.AlignLeft
+            |
+            Qt.AlignBottom
+            # Qt.AlignVCenter
         )
         self.setText(self.fmt_str)
 

piker/ui/_remote_ctl.py

@@ -15,8 +15,8 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 '''
-Remote control tasks for sending annotations (and maybe more cmds)
+Remote control tasks for sending annotations (and maybe more cmds) to
-to a chart from some other actor.
+a chart from some other actor.
 
 '''
 from __future__ import annotations
@@ -32,6 +32,7 @@ from typing import (
 )
 
 import tractor
+import trio
 from tractor import trionics
 from tractor import (
     Portal,
@@ -316,7 +317,9 @@ class AnnotCtl(Struct):
             )
             yield aid
         finally:
-            await self.remove(aid)
+            # async ipc send op
+            with trio.CancelScope(shield=True):
+                await self.remove(aid)
 
     async def redraw(
         self,

piker/ui/_search.py

@@ -15,7 +15,8 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 """
-qompleterz: embeddable search and complete using trio, Qt and rapidfuzz.
+qompleterz: embeddable search and complete using trio, Qt and
+rapidfuzz.
 
 """
 
@@ -46,6 +47,7 @@ import time
 from pprint import pformat
 
 from rapidfuzz import process as fuzzy
+import tractor
 import trio
 from trio_typing import TaskStatus
 
@@ -53,7 +55,7 @@ from piker.ui.qt import (
     size_policy,
     align_flag,
     Qt,
-    QtCore,
+    # QtCore,
     QtWidgets,
     QModelIndex,
     QItemSelectionModel,
@@ -920,7 +922,10 @@ async def fill_results(
 
             # issue multi-provider fan-out search request and place
             # "searching.." statuses on outstanding results providers
-            async with trio.open_nursery() as n:
+            async with (
+                tractor.trionics.collapse_eg(),
+                trio.open_nursery() as tn
+            ):
 
                 for provider, (search, pause) in (
                     _searcher_cache.copy().items()
@@ -944,7 +949,7 @@ async def fill_results(
                                 status_field='-> searchin..',
                             )
 
-                        await n.start(
+                        await tn.start(
                             pack_matches,
                             view,
                             has_results,
@@ -1004,12 +1009,14 @@ async def handle_keyboard_input(
     view.set_font_size(searchbar.dpi_font.px_size)
     send, recv = trio.open_memory_channel(616)
 
-    async with trio.open_nursery() as n:
+    async with (
-
+        tractor.trionics.collapse_eg(),  # needed?
+        trio.open_nursery() as tn
+    ):
         # start a background multi-searcher task which receives
         # patterns relayed from this keyboard input handler and
         # async updates the completer view's results.
-        n.start_soon(
+        tn.start_soon(
             partial(
                 fill_results,
                 searchw,

piker/ui/_style.py

@@ -269,6 +269,8 @@ def hcolor(name: str) -> str:
 
         # default ohlc-bars/curve gray
         'bracket': '#666666',  # like the logo
+        'pikers': '#616161',  # a trader shade of..
+        'beast': '#161616',  # in the dark alone.
 
         # bluish
         'charcoal': '#36454F',

piker/ui/order_mode.py

@@ -21,6 +21,7 @@ Chart trading, the only way to scalp.
 from __future__ import annotations
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
+from decimal import Decimal
 from functools import partial
 from pprint import pformat
 import time
@@ -41,7 +42,6 @@ from piker.accounting import (
     Position,
     mk_allocator,
     MktPair,
-    Symbol,
 )
 from piker.clearing import (
     open_ems,
@@ -143,6 +143,15 @@ class OrderMode:
     }
     _staged_order: Order | None = None
 
+    @property
+    def curr_mkt(self) -> MktPair:
+        '''
+        Deliver the currently selected `MktPair` according
+        chart state.
+
+        '''
+        return self.chart.linked.mkt
+
     def on_level_change_update_next_order_info(
         self,
         level: float,
@@ -172,7 +181,11 @@ class OrderMode:
         line.update_labels(order_info)
 
         # update bound-in staged order
-        order.price = level
+        mkt: MktPair = self.curr_mkt
+        order.price: Decimal = mkt.quantize(
+            size=level,
+            quantity_type='price',
+        )
         order.size = order_info['size']
 
         # when an order is changed we flip the settings side-pane to
@@ -187,7 +200,9 @@ class OrderMode:
 
     ) -> LevelLine:
 
-        level = order.price
+        # TODO, if we instead just always decimalize at the ems layer
+        # we can avoid this back-n-forth casting?
+        level = float(order.price)
 
         line = order_line(
             chart or self.chart,
@@ -224,7 +239,11 @@ class OrderMode:
             # the order mode allocator but we still need to update the
             # "staged" order message we'll send to the ems
             def update_order_price(y: float) -> None:
-                order.price = y
+                mkt: MktPair = self.curr_mkt
+                order.price: Decimal = mkt.quantize(
+                    size=y,
+                    quantity_type='price',
+                )
 
             line._on_level_change = update_order_price
 
@@ -275,34 +294,31 @@ class OrderMode:
         chart = cursor.linked.chart
         if (
             not chart
-            and cursor
+            and
-            and cursor.active_plot
+            cursor
+            and
+            cursor.active_plot
         ):
             return
 
         chart = cursor.active_plot
-        price = cursor._datum_xy[1]
+        price: float = cursor._datum_xy[1]
         if not price:
             # zero prices are not supported by any means
             # since that's illogical / a no-op.
             return
 
-        mkt: MktPair = self.chart.linked.mkt
-
-        # NOTE : we could also use instead,
-        # mkt.quantize(price, quantity_type='price')
-        # but it returns a Decimal and it's probably gonna
-        # be slower?
         # TODO: should we be enforcing this precision
-        # at a different layer in the stack? right now
+        # at a different layer in the stack?
-        # any precision error will literally be relayed
+        # |_ might require `MktPair` tracking in the EMS?
-        # all the way back from the backend.
+        # |_ right now any precision error will be relayed
-
+        #    all the way back from the backend and vice-versa..
-        price = round(
+        #
-            price,
+        mkt: MktPair = self.curr_mkt
-            ndigits=mkt.price_tick_digits,
+        price: Decimal = mkt.quantize(
+            size=price,
+            quantity_type='price',
         )
-
         order = self._staged_order = Order(
             action=action,
             price=price,
@@ -378,7 +394,7 @@ class OrderMode:
                 'oid': oid,
             })
 
-        if order.price <= 0:
+        if float(order.price) <= 0:
             log.error(
                 '*!? Invalid `Order.price <= 0` ?!*\n'
                 # TODO: make this present multi-line in object form
@@ -515,14 +531,15 @@ class OrderMode:
             # if an order msg is provided update the line
             # **from** that msg.
             if order:
-                if order.price <= 0:
+                price: float = float(order.price)
+                if price <= 0:
                     log.error(f'Order has 0 price, cancelling..\n{order}')
                     self.cancel_orders([order.oid])
                     return None
 
-                line.set_level(order.price)
+                line.set_level(price)
                 self.on_level_change_update_next_order_info(
-                    level=order.price,
+                    level=price,
                     line=line,
                     order=order,
                     # use the corresponding position tracker for the
@@ -538,14 +555,13 @@ class OrderMode:
 
     def on_fill(
         self,
-
         uuid: str,
         price: float,
         time_s: float,
 
         pointing: str | None = None,
 
-    ) -> None:
+    ) -> bool:
         '''
         Fill msg handler.
 
@@ -558,60 +574,83 @@ class OrderMode:
         - update fill bar size
 
         '''
-        dialog = self.dialogs[uuid]
+        # XXX WARNING XXX
+        # if a `Status(resp='error')` arrives *before* this
+        # fill-status, the `.dialogs` entry may have already been
+        # popped and thus the below will skipped.
+        #
+        # NOTE, to avoid this confusing scenario ensure that any
+        # errors delivered thru from the broker-backend are not just
+        # "noisy reporting" (like is very common from IB..) and are
+        # instead ONLY errors-causing-order-dialog-cancellation!
+        if not (dialog := self.dialogs.get(uuid)):
+            log.warning(
+                f'Order was already cleared from `.dialogs` ??\n'
+                f'uuid: {uuid!r}\n'
+            )
+            return False
+
         lines = dialog.lines
         chart = self.chart
 
-        # XXX: seems to fail on certain types of races?
+        if not lines:
-        # assert len(lines) == 2
-        if lines:
-            flume: Flume = self.feed.flumes[chart.linked.mkt.fqme]
-            _, _, ratio = flume.get_ds_info()
-
-            for chart, shm in [
-                (self.chart, flume.rt_shm),
-                (self.hist_chart, flume.hist_shm),
-            ]:
-                viz = chart.get_viz(chart.name)
-                index_field = viz.index_field
-                arr = shm.array
-
-                # TODO: borked for int index based..
-                index = flume.get_index(time_s, arr)
-
-                # get absolute index for arrow placement
-                arrow_index = arr[index_field][index]
-
-                self.arrows.add(
-                    chart.plotItem,
-                    uuid,
-                    arrow_index,
-                    price,
-                    pointing=pointing,
-                    color=lines[0].color
-                )
-        else:
             log.warn("No line(s) for order {uuid}!?")
+            return False
+
+        # update line state(s)
+        #
+        # ?XXX this fails on certain types of races?
+        # assert len(lines) == 2
+        flume: Flume = self.feed.flumes[chart.linked.mkt.fqme]
+        _, _, ratio = flume.get_ds_info()
+
+        for chart, shm in [
+            (self.chart, flume.rt_shm),
+            (self.hist_chart, flume.hist_shm),
+        ]:
+            viz = chart.get_viz(chart.name)
+            index_field = viz.index_field
+            arr = shm.array
+
+            # TODO: borked for int index based..
+            index = flume.get_index(time_s, arr)
+
+            # get absolute index for arrow placement
+            arrow_index = arr[index_field][index]
+
+            self.arrows.add(
+                chart.plotItem,
+                uuid,
+                arrow_index,
+                price,
+                pointing=pointing,
+                color=lines[0].color
+            )
 
     def on_cancel(
         self,
-        uuid: str
+        uuid: str,
 
-    ) -> None:
+    ) -> bool:
 
-        msg: Order = self.client._sent_orders.pop(uuid, None)
+        msg: Order|None = self.client._sent_orders.pop(uuid, None)
-
+        if msg is None:
-        if msg is not None:
-            self.lines.remove_line(uuid=uuid)
-            self.chart.linked.cursor.show_xhair()
-
-            dialog = self.dialogs.pop(uuid, None)
-            if dialog:
-                dialog.last_status_close()
-        else:
             log.warning(
                 f'Received cancel for unsubmitted order {pformat(msg)}'
             )
+            return False
+
+        # remove GUI line, show cursor.
+        self.lines.remove_line(uuid=uuid)
+        self.chart.linked.cursor.show_xhair()
+
+        # remove msg dialog (history)
+        dialog: Dialog|None = self.dialogs.pop(uuid, None)
+        if dialog:
+            dialog.last_status_close()
+
+        return True
+
 
     def cancel_orders_under_cursor(self) -> list[str]:
         return self.cancel_orders(
@@ -681,9 +720,9 @@ class OrderMode:
     ) -> Dialog | None:
         # NOTE: the `.order` attr **must** be set with the
         # equivalent order msg in order to be loaded.
-        order = msg.req
+        order: Order = msg.req
         oid = str(msg.oid)
-        symbol = order.symbol
+        symbol: str = order.symbol
 
         # TODO: MEGA UGGG ZONEEEE!
         src = msg.src
@@ -702,13 +741,22 @@ class OrderMode:
         order.oid = str(order.oid)
         order.brokers = [brokername]
 
-        # TODO: change this over to `MktPair`, but it's
+        # ?TODO? change this over to `MktPair`, but it's gonna be
-        # gonna be tough since we don't have any such data
+        # tough since we don't have any such data really in our
-        # really in our clearing msg schema..
+        # clearing msg schema..
-        order.symbol = Symbol.from_fqme(
+        # BUT WAIT! WHY do we even want/need this!?
-            fqsn=fqme,
+        #
-            info={},
+        # order.symbol = self.curr_mkt
-        )
+        #
+        # XXX, the old approach.. which i don't quire member why..
+        # -[ ] verify we for sure don't require this any more!
+        #  |_https://github.com/pikers/piker/issues/517
+        #
+        # order.symbol = Symbol.from_fqme(
+        #     fqsn=fqme,
+        #     info={},
+        # )
+
         maybe_dialog: Dialog | None = self.submit_order(
             send_msg=False,
             order=order,
@@ -766,6 +814,7 @@ async def open_order_mode(
             brokerd_accounts,
             ems_dialog_msgs,
         ),
+        tractor.trionics.collapse_eg(),
         trio.open_nursery() as tn,
 
     ):
@@ -1030,13 +1079,23 @@ async def process_trade_msg(
     if name in (
         'position',
     ):
-        sym: MktPair = mode.chart.linked.mkt
+        mkt: MktPair = mode.chart.linked.mkt
         pp_msg_symbol = msg['symbol'].lower()
-        fqme = sym.fqme
+        pp_msg_bsmktid = msg['bs_mktid']
-        broker = sym.broker
+        fqme = mkt.fqme
+        broker = mkt.broker
         if (
+            # match on any backed-specific(-unique)-ID first!
+            (
+                pp_msg_bsmktid
+                and
+                mkt.bs_mktid == pp_msg_bsmktid
+            )
+            or
+            # OW try against what's provided as an FQME..
             pp_msg_symbol == fqme
-            or pp_msg_symbol == fqme.removesuffix(f'.{broker}')
+            or
+            pp_msg_symbol == fqme.removesuffix(f'.{broker}')
         ):
             log.info(
                 f'Loading position for `{fqme}`:\n'
@@ -1059,7 +1118,7 @@ async def process_trade_msg(
         return
 
     msg = Status(**msg)
-    resp = msg.resp
+    # resp: str = msg.resp
     oid = msg.oid
     dialog: Dialog = mode.dialogs.get(oid)
 
@@ -1101,7 +1160,7 @@ async def process_trade_msg(
                         )
                     )
                 ):
-                    msg.req = order
+                    msg.req: Order = order
                     dialog: (
                         Dialog
                         # NOTE: on an invalid order submission (eg.
@@ -1123,19 +1182,32 @@ async def process_trade_msg(
                         mode.on_submit(oid)
 
         case Status(resp='error'):
-
-            # do all the things for a cancel:
-            # - drop order-msg dialog from client table
-            # - delete level line from view
-            mode.on_cancel(oid)
-
             # TODO: parse into broker-side msg, or should we
             # expect it to just be **that** msg verbatim (since
             # we'd presumably have only 1 `Error` msg-struct)
             broker_msg: dict = msg.brokerd_msg
+
+            # XXX NOTE, this presumes the rxed "error" is
+            # order-dialog-cancel-causing, THUS backends much ONLY
+            # relay errors of this "severity"!!
             log.error(
-                f'Order {oid}->{resp} with:\n{pformat(broker_msg)}'
+                f'Order errored ??\n'
+                f'oid: {oid!r}\n'
+                f'\n'
+                f'{pformat(broker_msg)}\n'
+                f'\n'
+                f'=> CANCELLING ORDER DIALOG <=\n'
+
+                # from tractor.devx.pformat import ppfmt
+                # !TODO LOL, wtf the msg is causing
+                # a recursion bug!
+                # -[ ] get this shit on msgspec stat!
+                # f'{ppfmt(broker_msg)}'
             )
+            # do all the things for a cancel:
+            # - drop order-msg dialog from client table
+            # - delete level line from view
+            mode.on_cancel(oid)
 
         case Status(resp='canceled'):
             # delete level line from view
@@ -1151,10 +1223,10 @@ async def process_trade_msg(
             # TODO: UX for a "pending" clear/live order
             log.info(f'Dark order triggered for {fmtmsg}')
 
+        # TODO: do the struct-msg version, blah blah..
+        # req=Order(exec_mode='live', action='alert') as req,
         case Status(
             resp='triggered',
-            # TODO: do the struct-msg version, blah blah..
-            # req=Order(exec_mode='live', action='alert') as req,
             req={
                 'exec_mode': 'live',
                 'action': 'alert',
@@ -1166,7 +1238,7 @@ async def process_trade_msg(
             tm = time.time()
             mode.on_fill(
                 oid,
-                price=req.price,
+                price=float(req.price),
                 time_s=tm,
             )
             mode.lines.remove_line(uuid=oid)
@@ -1221,7 +1293,7 @@ async def process_trade_msg(
             tm = details['broker_time']
             mode.on_fill(
                 oid,
-                price=details['price'],
+                price=float(details['price']),
                 time_s=tm,
                 pointing='up' if action == 'buy' else 'down',
             )

pyproject.toml

@@ -23,7 +23,7 @@ name = "piker"
 version = "0.1.0a0dev0"
 description = "trading gear for hackers"
 authors = [{ name = "Tyler Goodlet", email = "goodboy_foss@protonmail.com" }]
-requires-python = ">=3.12, <3.13"
+requires-python = ">=3.12"
 license = "AGPL-3.0-or-later"
 readme = "README.rst"
 keywords = [
@@ -39,8 +39,8 @@ classifiers = [
     "Operating System :: POSIX :: Linux",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Intended Audience :: Financial and Insurance Industry",
     "Intended Audience :: Science/Research",
     "Intended Audience :: Developers",
@@ -49,13 +49,13 @@ classifiers = [
 dependencies = [
     "async-generator >=1.10, <2.0.0",
     "attrs >=23.1.0, <24.0.0",
-    "bidict >=0.22.1, <0.23.0",
+    "bidict >=0.23.1",
     "colorama >=0.4.6, <0.5.0",
     "colorlog >=6.7.0, <7.0.0",
     "ib-insync >=0.9.86, <0.10.0",
-    "numba >=0.59.0, <0.60.0",
+    "numpy>=2.0",
-    "numpy >=1.25, <2.0",
+    "polars >=0.20.6",
-    "polars >=0.18.13, <0.19.0",
+    "polars-fuzzy-match>=0.1.5",
     "pygments >=2.16.1, <3.0.0",
     "rich >=13.5.2, <14.0.0",
     "tomli >=2.0.1, <3.0.0",
@@ -63,21 +63,27 @@ dependencies = [
     "trio-util >=0.7.0, <0.8.0",
     "trio-websocket >=0.10.3, <0.11.0",
     "typer >=0.9.0, <1.0.0",
-    "rapidfuzz >=3.5.2, <4.0.0",
+    "trio >=0.27",
-    "pdbp >=1.5.0, <2.0.0",
+    "pendulum",
-    "trio >=0.24, <0.25",
-    "pendulum >=3.0.0, <4.0.0",
     "httpx >=0.27.0, <0.28.0",
     "cryptofeed >=2.4.0, <3.0.0",
-    "pyarrow >=17.0.0, <18.0.0",
+    "pyarrow>=18.0.0",
     "websockets ==12.0",
-    "msgspec",
+    "msgspec>=0.19.0,<0.20",
     "tractor",
-    "asyncvnc",
     "tomlkit",
+    "trio-typing>=0.10.0",
+    "numba>=0.61.0",
+    "pyvnc",
 ]
+# ------ dependencies ------
 
-[project.optional-dependencies]
+
+# TODO: add an `--only daemon` group for running non-ui / pikerd
+# service tree in distributed mode B)
+# https://docs.astral.sh/uv/concepts/projects/dependencies/#optional-dependencies
+
+[dependency-groups]
 uis = [
     # https://docs.astral.sh/uv/concepts/projects/dependencies/#optional-dependencies
     # TODO: make sure the levenshtein shit compiles on nix..
@@ -90,12 +96,11 @@ uis = [
     # for consideration,
     # - 'visidata'
 
-    # TODO: add an `--only daemon` group for running non-ui / pikerd
+    "qdarkstyle >=3.0.2, <4.0.0",
-    # service tree in distributed mode B)
+    "pyqt6 >=6.7.0, <7.0.0",
-    # https://docs.astral.sh/uv/concepts/projects/dependencies/#optional-dependencies
+    "pyqtgraph",
 ]
 
-[dependency-groups]
 # TODO: a toolset that makes debugging a `pikerd` service (tree) easy
 # to hack on directly using more or less the local env:
 # - xonsh + xxh
@@ -104,30 +109,92 @@ uis = [
 #
 # console ehancements and eventually remote debugging extras/helpers.
 # use `uv --dev` to enable
-dev = [
+repl = [
-    "pytest >=6.0.0, <7.0.0",
+  # debug
-    "elasticsearch >=8.9.0, <9.0.0",
+  "pdbp >=1.5.0, <2.0.0",
-    "xonsh >=0.14.2, <0.15.0",
-    "prompt-toolkit ==3.0.40",
-    "cython >=3.0.0, <4.0.0",
     "greenback >=1.1.1, <2.0.0",
-    "ruff>=0.9.6",
+  "xonsh",
+    "prompt-toolkit ==3.0.40",
+    "pyperclip>=1.9.0",
+
 ]
+testing = [
+  "pytest",
+]
+de = [
+  # DE-specific
+  "i3ipc>=2.2.1",
+]
+dev = [
+  # https://docs.astral.sh/uv/concepts/projects/dependencies/#development-dependencies
+  "cython >=3.0.0, <4.0.0",
+
+  # nested deps-groups
+  # https://docs.astral.sh/uv/concepts/projects/dependencies/#nesting-groups
+  {include-group = 'uis'},
+  {include-group = 'repl'},
+  {include-group = 'testing'},
+  {include-group = 'de'},
+]
+lint = [
+  # XXX, with flake.nix needs to be from nixpkgs
+  "ruff>=0.9.6" 
+  #
+  # ^TODO? these markers don't work; use deps-flags for now?
+  # ; os_name != 'nixos' and platform_system != 'NixOS'",
+  # ; defined('IN_NIX_SHELL')",
+]
+dbs = [
+  "elasticsearch >=8.9.0, <9.0.0",
+]
+# ------ dependency-groups ------
+
+
+[tool.pytest.ini_options]
+# https://docs.pytest.org/en/stable/reference/reference.html#configuration-options
+testpaths = [
+    "tests",
+]
+# https://docs.pytest.org/en/stable/reference/reference.html#confval-console_output_style
+console_output_style = 'progress'
+
+# https://docs.pytest.org/en/stable/how-to/plugins.html#disabling-plugins-from-autoloading
+# https://docs.pytest.org/en/stable/how-to/plugins.html#deactivating-unregistering-a-plugin-by-name
+addopts = '-p no:xonsh'
+# ------ tool.pytest ------
+
 
 [project.scripts]
 piker = "piker.cli:cli"
 pikerd = "piker.cli:pikerd"
 ledger = "piker.accounting.cli:ledger"
+# ------ project.scripts ------
 
 [tool.hatch.build.targets.sdist]
 include = ["piker"]
-
 [tool.hatch.build.targets.wheel]
 include = ["piker"]
+# ------ tool.hatch ------
+
+
+# TODO? move to a `uv.toml`?
+[tool.uv]
+python-preference = 'system'
+python-downloads = 'manual'
+# https://docs.astral.sh/uv/concepts/projects/dependencies/#default-groups
+default-groups = ['uis', 'dev']
+# ------ tool.uv ------
+
 
 [tool.uv.sources]
 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" }
-msgspec = { git = "https://github.com/jcrist/msgspec.git" }
+pyvnc = { git = "https://github.com/regulad/pyvnc.git" }
-tractor = { path = "../tractor", editable = true }
+
+# XXX since, we're like, always hacking new shite all-the-time. Bp
+tractor = { git = "https://github.com/goodboy/tractor.git", branch ="piker_pin" }
+# tractor = { git = "https://pikers.dev/goodboy/tractor", branch = "piker_pin" }
+# tractor = { git = "https://pikers.dev/goodboy/tractor", branch = "main" }
+# ------ goodboy ------
+# hackin dev-envs, usually there's something new he's hackin in..
+# tractor = { path = "../tractor", editable = true }

ruff.toml

@@ -62,8 +62,9 @@ ignore-init-module-imports = false
 fixable = ["ALL"]
 unfixable = []
 
+# TODO? uhh why no work!?
 # Allow unused variables when underscore-prefixed.
-dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+# dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 
 [format]
 # Use single quotes in `ruff format`.

snippets/qt_screen_info.py

@@ -1,4 +1,22 @@
-"""
+# 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/>.
+
+'''
+A per-display, DPI (scaling) info dumper.
+
 Resource list for mucking with DPIs on multiple screens:
 
 - https://stackoverflow.com/questions/42141354/convert-pixel-size-to-point-size-for-fonts-on-multiple-platforms
@@ -12,89 +30,86 @@ Resource list for mucking with DPIs on multiple screens:
 - https://stackoverflow.com/questions/16561879/what-is-the-difference-between-logicaldpix-and-physicaldpix-in-qt
 - https://doc.qt.io/qt-5/qguiapplication.html#screenAt
 
-"""
+'''
 
 from pyqtgraph import QtGui
-from PyQt5.QtCore import (
+from PyQt6 import (
-     Qt, QCoreApplication
+    QtCore,
+    QtWidgets,
+)
+from PyQt6.QtCore import (
+    Qt,
+    QCoreApplication,
+    QSize,
+    QRect,
 )
 
 # Proper high DPI scaling is available in Qt >= 5.6.0. This attibute
 # must be set before creating the application
 if hasattr(Qt, 'AA_EnableHighDpiScaling'):
-    QCoreApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
+    QCoreApplication.setAttribute(
+        Qt.AA_EnableHighDpiScaling,
+        True,
+    )
 
 if hasattr(Qt, 'AA_UseHighDpiPixmaps'):
-    QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
+    QCoreApplication.setAttribute(
+        Qt.AA_UseHighDpiPixmaps,
+        True,
+    )
 
-
+app = QtWidgets.QApplication([])
-app = QtGui.QApplication([])
+window = QtWidgets.QMainWindow()
-window = QtGui.QMainWindow()
+main_widget = QtWidgets.QWidget()
-main_widget = QtGui.QWidget()
 window.setCentralWidget(main_widget)
 window.show()
 
-pxr = main_widget.devicePixelRatioF()
+pxr: float = main_widget.devicePixelRatioF()
 
-# screen_num = app.desktop().screenNumber()
+# explicitly get main widget and primary displays
-# screen = app.screens()[screen_num]
+current_screen: QtGui.QScreen = app.screenAt(
-
+    main_widget.geometry().center()
-screen = app.screenAt(main_widget.geometry().center())
-
-name = screen.name()
-size = screen.size()
-geo = screen.availableGeometry()
-phydpi = screen.physicalDotsPerInch()
-logdpi = screen.logicalDotsPerInch()
-
-print(
-    # f'screen number: {screen_num}\n',
-    f'screen name: {name}\n'
-    f'screen size: {size}\n'
-    f'screen geometry: {geo}\n\n'
-    f'devicePixelRationF(): {pxr}\n'
-    f'physical dpi: {phydpi}\n'
-    f'logical dpi: {logdpi}\n'
 )
+primary_screen: QtGui.QScreen = app.primaryScreen()
 
-print('-'*50)
+screen: QtGui.QScreen
+for screen in app.screens():
+    name: str = screen.name()
+    model: str = screen.model().rstrip()
+    size: QSize = screen.size()
+    geo: QRect = screen.availableGeometry()
+    phydpi: float = screen.physicalDotsPerInch()
+    logdpi: float = screen.logicalDotsPerInch()
+    is_primary: bool = screen is primary_screen
+    is_current: bool = screen is current_screen
 
-screen = app.primaryScreen()
+    print(
+        f'------ screen name: {name} ------\n'
+        f'|_primary: {is_primary}\n'
+        f' _current: {is_current}\n'
+        f' _model: {model}\n'
+        f' _screen size: {size}\n'
+        f' _screen geometry: {geo}\n'
+        f' _devicePixelRationF(): {pxr}\n'
+        f' _physical dpi: {phydpi}\n'
+        f' _logical dpi: {logdpi}\n'
+    )
 
-name = screen.name()
+# app-wide font info
-size = screen.size()
-geo = screen.availableGeometry()
-phydpi = screen.physicalDotsPerInch()
-logdpi = screen.logicalDotsPerInch()
-
-print(
-    # f'screen number: {screen_num}\n',
-    f'screen name: {name}\n'
-    f'screen size: {size}\n'
-    f'screen geometry: {geo}\n\n'
-    f'devicePixelRationF(): {pxr}\n'
-    f'physical dpi: {phydpi}\n'
-    f'logical dpi: {logdpi}\n'
-)
-
-
-# app-wide font
 font = QtGui.QFont("Hack")
 # use pixel size to be cross-resolution compatible?
 font.setPixelSize(6)
 
-
 fm = QtGui.QFontMetrics(font)
-fontdpi = fm.fontDpi()
+fontdpi: float = fm.fontDpi()
-font_h = fm.height()
+font_h: int = fm.height()
-
-string = '10000'
-str_br = fm.boundingRect(string)
-str_w = str_br.width()
 
+string: str = '10000'
+str_br: QtCore.QRect = fm.boundingRect(string)
+str_w: int = str_br.width()
 
 print(
-    # f'screen number: {screen_num}\n',
+    f'------ global font settings ------\n'
     f'font dpi: {fontdpi}\n'
     f'font height: {font_h}\n'
     f'string bounding rect: {str_br}\n'

tags

@@ -0,0 +1 @@
+TAG_feed_status_update	./piker/data/feed.py	/TAG_feed_status_update/

tests/conftest.py

@@ -15,6 +15,12 @@ from piker.service import (
 from piker.log import get_console_log
 
 
+# include `tractor`'s built-in fixtures!
+pytest_plugins: tuple[str] = (
+    "tractor._testing.pytest",
+)
+
+
 def pytest_addoption(parser):
     parser.addoption("--ll", action="store", dest='loglevel',
                      default=None, help="logging level to set when testing")

tests/test_accounting.py

@@ -12,12 +12,14 @@ from piker import config
 from piker.accounting import (
     Account,
     calc,
-    Position,
+    open_account,
-    TransactionLedger,
-    open_trade_ledger,
     load_account,
     load_account_from_ledger,
+    open_trade_ledger,
+    Position,
+    TransactionLedger,
 )
+import tractor
 
 
 def test_root_conf_networking_section(
@@ -53,12 +55,17 @@ def test_account_file_default_empty(
 )
 def test_paper_ledger_position_calcs(
     fq_acnt: tuple[str, str],
+    debug_mode: bool,
 ):
     broker: str
     acnt_name: str
     broker, acnt_name = fq_acnt
 
-    accounts_path: Path = config.repodir() / 'tests' / '_inputs'
+    accounts_path: Path = (
+        config.repodir()
+        / 'tests'
+        / '_inputs'  # tests-local-subdir
+    )
 
     ldr: TransactionLedger
     with (
@@ -77,6 +84,7 @@ def test_paper_ledger_position_calcs(
             ledger=ldr,
 
             _fp=accounts_path,
+            debug_mode=debug_mode,
 
         ) as (dfs, ledger),
 
@@ -102,3 +110,87 @@ def test_paper_ledger_position_calcs(
         df = dfs[xrp]
         assert df['cumsize'][-1] == 0
         assert pos.cumsize == 0
+
+
+
+@pytest.mark.parametrize(
+    'fq_acnt',
+    [
+        ('ib', 'algopaper'),
+    ],
+)
+def test_ib_account_with_duplicated_mktids(
+    fq_acnt: tuple[str, str],
+    debug_mode: bool,
+):
+    # ?TODO, once we start symcache-incremental-update-support?
+    # from piker.data import (
+    #     open_symcache,
+    # )
+    #
+    # async def main():
+    #     async with (
+    #         # TODO: do this as part of `open_account()`!?
+    #         open_symcache(
+    #             'ib',
+    #             only_from_memcache=True,
+    #         ) as symcache,
+    #     ):
+
+
+    from piker.brokers.ib.ledger import (
+        tx_sort,
+
+        # ?TODO, once we want to pull lowlevel txns and process them?
+        # norm_trade_records,
+        # update_ledger_from_api_trades,
+    )
+
+    broker: str
+    acnt_id: str = 'algopaper'
+    broker, acnt_id = fq_acnt
+    accounts_def = config.load_accounts([broker])
+    assert accounts_def[f'{broker}.{acnt_id}']
+
+    ledger: TransactionLedger
+    acnt: Account
+    with (
+        tractor.devx.maybe_open_crash_handler(pdb=debug_mode),
+
+        open_trade_ledger(
+            'ib',
+            acnt_id,
+            tx_sort=tx_sort,
+
+            # TODO, eventually incrementally updated for IB..
+            # symcache=symcache,
+            symcache=None,
+            allow_from_sync_code=True,
+
+        ) as ledger,
+
+        open_account(
+            'ib',
+            acnt_id,
+            write_on_exit=True,
+        ) as acnt,
+    ):
+        # per input params
+        symcache = ledger.symcache
+        assert not (
+            symcache.pairs
+            or
+            symcache.pairs
+            or
+            symcache.mktmaps
+        )
+        # re-compute all positions that have changed state.
+        # TODO: likely we should change the API to return the
+        # position updates from `.update_from_ledger()`?
+        active, closed = acnt.dump_active()
+
+        # breakpoint()
+
+        # TODO, (see above imports as well) incremental update from
+        #      (updated) ledger?
+        # -[ ] pull some code from `.ib.broker` content.

tests/test_ems.py

@@ -42,7 +42,7 @@ from piker.accounting import (
     unpack_fqme,
 )
 from piker.accounting import (
-    open_pps,
+    open_account,
     Position,
 )
 
@@ -136,7 +136,7 @@ def load_and_check_pos(
 
 ) -> None:
 
-    with open_pps(ppmsg.broker, ppmsg.account) as table:
+    with open_account(ppmsg.broker, ppmsg.account) as table:
 
         if ppmsg.size == 0:
             assert ppmsg.symbol not in table.pps
@@ -179,7 +179,7 @@ def test_ems_err_on_bad_broker(
         # NOTE: emsd should error on the actor's enabled modules
         # import phase, when looking for a backend named `doggy`.
         except tractor.RemoteActorError as re:
-            assert re.type == ModuleNotFoundError
+            assert re.type is ModuleNotFoundError
 
     run_and_tollerate_cancels(load_bad_fqme)
 

tests/test_questrade.py

@@ -142,7 +142,12 @@ async def test_concurrent_tokens_refresh(us_symbols, loglevel):
         # async with tractor.open_nursery() as n:
         #     await n.run_in_actor('other', intermittently_refresh_tokens)
 
-        async with trio.open_nursery() as n:
+        async with (
+            tractor.trionics.collapse_eg(),
+            trio.open_nursery(
+            # strict_exception_groups=False,
+            ) as n
+        ):
 
             quoter = await qt.stock_quoter(client, us_symbols)
 
@@ -383,7 +388,9 @@ async def test_quote_streaming(tmx_symbols, loglevel, stream_what):
             else:
                 symbols = [tmx_symbols]
 
-            async with trio.open_nursery() as n:
+            async with trio.open_nursery(
+                strict_exception_groups=False,
+            ) as n:
                 for syms, func in zip(symbols, stream_what):
                     n.start_soon(func, feed, syms)