Qubx 3.6.2.dev1__tar.gz → 3.8.0__tar.gz

{qubx-3.6.2.dev1 → qubx-3.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: Qubx
-Version: 3.6.2.dev1
+Version: 3.8.0
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.6.2.dev1'
-__version_tuple__ = version_tuple = (3, 6, 2, 'dev1')
+__version__ = version = '3.8.0'
+__version_tuple__ = version_tuple = (3, 8, 0)
 
 __commit_id__ = commit_id = None

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/connectors/ccxt/connector.py

@@ -52,6 +52,7 @@ from qubx.core.basics import (
     OrderStatus,
     OrderType,
     Position,
+    RejectCause,
     dt_64,
     resolve_reduce_only,
 )
@@ -94,6 +95,7 @@ from .utils import (
     instrument_to_ccxt_symbol,
     normalize_margin_mode,
     prepare_ccxt_order_payload,
+    reject_cause_of,
 )
 
 # Venue-verdict exceptions: every one of these is the venue refusing the order,
@@ -380,6 +382,7 @@ class CcxtConnector(ChannelEmitter):
                 client_order_id=client_id,
                 reason=str(error),
                 code=type(error).__name__,
+                cause=reject_cause_of(error),
             )
         )
 
@@ -441,6 +444,7 @@ class CcxtConnector(ChannelEmitter):
         venue_order_id: str | None,
         reason: str | None = None,
         code: str | None = None,
+        cause: RejectCause = RejectCause.UNKNOWN,
     ) -> None:
         # Carry both ids: AM's reject handler resolves the order by cid first, then venue id,
         # so the order can revert out of PENDING_CANCEL regardless of which id the caller had.
@@ -451,6 +455,7 @@ class CcxtConnector(ChannelEmitter):
                 venue_order_id=venue_order_id,
                 reason=reason or f"venue rejected cancel for {venue_order_id or client_order_id}",
                 code=code,
+                cause=cause,
             )
         )
 
@@ -772,6 +777,7 @@ class CcxtConnector(ChannelEmitter):
                 venue_order_id=venue_order_id,
                 reason=str(error),
                 code=type(error).__name__,
+                cause=reject_cause_of(error),
             )
         )
 

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/connectors/ccxt/exchanges/binance/exchange.py

@@ -731,7 +731,20 @@ class BinancePortfolioMargin(BinanceQVUSDM):
                     "defaultType": "swap",
                     "portfolioMargin": True,
                     "fetchMarkets": ["spot", "linear", "inverse"],
-                }
+                },
+                # ccxt's handle_errors reads the URL-scoped map BEFORE the global one, and its
+                # portfolioMargin group maps -2019 to OperationFailed — so a papi order refused
+                # for margin never reached BinanceQV's global "-2019": InsufficientFunds. It has
+                # to sit here, in the LAST describe of the chain: binanceusdm's own describe runs
+                # after BinanceQV's and would overwrite the group. Measured on BINANCE.PM: 105
+                # margin refusals arrived as OperationFailed and were logged as unexpected errors.
+                "exceptions": {
+                    "portfolioMargin": {
+                        "exact": {
+                            "-2019": InsufficientFunds,
+                        },
+                    },
+                },
             },
         )
 

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/connectors/ccxt/utils.py

@@ -22,6 +22,7 @@ from qubx.core.basics import (
     OrderSide,
     OrderStatus,
     Position,
+    RejectCause,
     classify_origin,
     dt_64,
 )
@@ -58,6 +59,19 @@ _CCXT_STATUS_MAP: dict[str, OrderStatus] = {
     "rejected": OrderStatus.REJECTED,
 }
 
+# - ccxt normalises every venue's error into its own exception classes, so the class name is
+#   already a portable vocabulary; this is the reading of it the framework acts on. Names, not
+#   classes, so a ccxt version that drops one does not break the import.
+_REJECT_CAUSE_BY_CCXT_ERROR: dict[str, RejectCause] = {
+    "InsufficientFunds": RejectCause.INSUFFICIENT_MARGIN,
+    "OrderNotFillable": RejectCause.NOT_FILLABLE,
+    "OrderImmediatelyFillable": RejectCause.NOT_FILLABLE,
+    "RateLimitExceeded": RejectCause.RATE_LIMITED,
+    "DDoSProtection": RejectCause.RATE_LIMITED,
+    "OrderNotFound": RejectCause.NOT_FOUND,
+    "InvalidOrder": RejectCause.TOO_SMALL,
+}
+
 
 def info_float(info: dict[str, Any], key: str) -> float | None:
     """Parse an optional numeric field from a raw venue payload; None when absent/malformed.
@@ -693,3 +707,10 @@ def ccxt_convert_timeframe_to_exchange_format(timeframe: str) -> str | None:
         _t = re.match(r"(\d+)(\w+)", timeframe)
         timeframe = f"{_t[1]}{_t[2][0].lower()}" if _t and len(_t.groups()) > 1 else timeframe
     return timeframe
+
+
+def reject_cause_of(error: Exception) -> RejectCause:
+    """
+    Classify a ccxt error for callers that cannot read venue codes. UNKNOWN when unmapped.
+    """
+    return _REJECT_CAUSE_BY_CCXT_ERROR.get(type(error).__name__, RejectCause.UNKNOWN)

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/core/account_manager/diffs.py

@@ -30,7 +30,8 @@ BALANCE_ABS_TOL = 0.01
 
 # Maintenance margin re-marks with every snapshot's mark price, so RTOL-tight comparison
 # emits a diff per position per poll. Only a material move (leverage/size change) is worth
-# re-syncing; sub-0.5% (and sub-cent) drift is mark noise.
+# re-syncing; sub-0.5% (and sub-cent) drift is mark noise. Measured over one live run: 175
+# diffs, median $0.000052, only one above a cent — and that one was a real position change.
 MARGIN_RTOL = 5e-3
 
 

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/core/account_manager/reconciler.py

@@ -19,6 +19,7 @@ import numpy as np
 from qubx import area_logger
 from qubx.core.account_manager.diffs import (
     BalanceMismatch,
+    Diff,
     Differ,
     LocalOrderMissing,
     LocalPositionMissing,
@@ -433,8 +434,30 @@ class Reconciler:
         state.mark_snapshot_applied(snap.as_of)
         changed = changed_positions if changed_positions is not None else []
         actions: list[Action] = []
-        for difference in self._differ.diff(state, snap):
+        differences = self._differ.diff(state, snap)
+        # - a snapshot requested before a deal was booked cannot contain that deal, so letting it
+        #   write the position rewinds a real fill. The decision is per instrument, not per diff:
+        #   a size change always brings a margin change, and PositionFieldMismatch routes through
+        #   reconcile_position_from_snapshot, which is authoritative for size and avg-price too.
+        #   Measured LIGHTER 2026-08-28 (ENAUSDC 272.6 -> 181.8, 84ms after the deal booked) and
+        #   BINANCE.UM (TRXUSDT 146 -> 127 against a snapshot 1.58s stale); on ALGOUSDT the
+        #   executor sized its next clip off the rewound number and overshot by 16.9%.
+        stale_for = {
+            instr
+            for instr in {self._position_instrument(d) for d in differences}
+            if instr is not None
+            and (booked := state.get_position_deal_booked_at(instr)) is not None
+            and booked > snap.as_of
+        }
+        for instr in stale_for:
+            _log.info(
+                f"[{state.exchange}] reconcile: <y>{instr}</y> snapshot as_of={snap.as_of} predates a deal "
+                f"booked at {state.get_position_deal_booked_at(instr)} — keeping the local position"
+            )
+        for difference in differences:
             _log.debug(difference.describe())
+            if self._position_instrument(difference) in stale_for:
+                continue
             # - each atom is applied in isolation: a handler that raises (e.g. a venue/state
             #   surprise) must not sink the rest of the snapshot reconcile (balances/figures/
             #   other positions). Log and move on; the next snapshot re-derives the diff.
@@ -452,7 +475,7 @@ class Reconciler:
                         self._recover_order(state, snap_order, snap.as_of)
 
                     case OrderFieldMismatch(origin=snap_order):
-                        if (ev := self._reconcile_order(state, snap_order)) is not None:
+                        if (ev := self._reconcile_order(state, snap_order, now)) is not None:
                             actions.append(RouteEvent(ev))
 
                     # - size diff = missed deals
@@ -494,6 +517,18 @@ class Reconciler:
 
         return actions + self._dispatch(SnapshotIn(snap), state, now)
 
+    @staticmethod
+    def _position_instrument(difference: Diff) -> Instrument | None:
+        """
+        The instrument a position diff is about, or None for the order and balance diffs.
+        """
+        match difference:
+            case PositionFieldMismatch(origin=pos):
+                return pos.instrument
+            case OriginalPositionMissing(position=pos) | LocalPositionMissing(position=pos):
+                return pos.instrument
+        return None
+
     @staticmethod
     def _recover_order(state: AccountState, snap_order: Order, as_of: np.datetime64) -> Order:
         # - venue order absent locally: trust the producer-assigned origin (only the connector
@@ -592,20 +627,38 @@ class Reconciler:
             )
         return state.get_position(instrument)
 
-    def _reconcile_order(self, state: AccountState, snap_order: Order) -> Action | None:
+    def _reconcile_order(self, state: AccountState, snap_order: Order, now: np.datetime64) -> Action | None:
         """Apply a snapshot order's status/filled to local state; return the fill event to route.
 
-        Snapshot is authoritative for the order's own state. Guards: skip if locally terminal or
-        not venue-newer; never wipe an in-flight pending marker (the venue resolves that race).
+        Snapshot is authoritative for the order's own state. Skipped when the order is locally
+        terminal, and while a pending marker is still inside the confirm window — see
+        _pending_expired. For anything else the snapshot has to be venue-newer.
         """
         local = state.get_active_order(snap_order.client_order_id)
-        if local is None or local.status.is_terminal or not self._venue_newer(snap_order, local):
+        if local is None or local.status.is_terminal:
             return None
-        if local.status.is_pending and not snap_order.status.is_terminal:
+        if local.status.is_pending:
+            # - a pending marker carries the local clock while the snapshot carries the venue's, so
+            #   _venue_newer cannot judge it: the confirm window decides instead
+            if not snap_order.status.is_terminal and not self._pending_expired(local, now):
+                return None
+        elif not self._venue_newer(snap_order, local):
             return None
         self._apply_order_snapshot(state, local, snap_order)
         return self._fill_event(local)
 
+    def _pending_expired(self, local: Order, now: np.datetime64) -> bool:
+        """
+        True once a pending marker has outlived the confirm window with the venue still holding the
+        order live — the cancel or update never reached it, so the snapshot has to win.
+
+        Inside the window the marker is defended: a snapshot fetched before the cancel landed shows
+        the order alive, and reverting then would undo a correct PENDING_CANCEL. Measured cancel
+        confirm on LIGHTER is 568 ms median, so the window is ~9x headroom. Both stamps are the
+        local clock — transition_order stamps a locally-driven transition with `now`.
+        """
+        return local.last_update_time is not None and (now - local.last_update_time) >= self._order_confirm_wait  # type: ignore
+
     @staticmethod
     def _venue_newer(snap: Order, local: Order) -> bool:
         # - venue-vs-venue only (the connector stamps last_update_time on snapshot orders); no

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/core/account_manager/reducer.py

@@ -280,6 +280,7 @@ def _handle_rejected(state: AccountState, event: OrderRejectedEvent, now: np.dat
         return ApplyResult()
     order.rejected_reason = event.reason
     order.error_code = event.code
+    order.reject_cause = event.cause
     order = transition(state, order.client_order_id, OrderStatus.REJECTED, now, update_time=event.last_update_time)
     return ApplyResult(order=order, order_change=OrderChange.REJECTED)
 
@@ -300,7 +301,7 @@ def _reconciled_past(state: AccountState, instrument: Instrument, deal: Deal) ->
     return watermark is not None and deal.time <= watermark
 
 
-def _book_deal(state: AccountState, instrument: Instrument, deal: Deal) -> Position:
+def _book_deal(state: AccountState, instrument: Instrument, deal: Deal, now: np.datetime64) -> Position:
     """Apply a deal's effect to the position and balances. Caller dedups first.
 
     Futures/swap: credits realized PnL and debits the fee to the settle-currency
@@ -314,6 +315,8 @@ def _book_deal(state: AccountState, instrument: Instrument, deal: Deal) -> Posit
     _before = pos.quantity
     realized_pnl, fee = pos.update_position_by_deal(deal, state.conversion_rate(instrument))
     logger.debug("deal {} amt={} {}->{} tid={}", instrument.symbol, deal.amount, _before, pos.quantity, deal.trade_id)
+    # - a position snapshot requested before this moment cannot contain this deal
+    state.mark_position_deal_booked(instrument, now)
     if instrument.is_futures():
         state.mark_cash_currency(instrument.settle)
         # TODO(account-mgmt): fee is folded into settle here (correct when
@@ -387,11 +390,13 @@ def _handle_fill(state: AccountState, event: OrderFilledEvent, now: np.datetime6
         if event.fill is not None
         else None
     )
-    position = _book_deal(state, order.instrument, deal) if deal is not None and order.instrument is not None else None
+    position = (
+        _book_deal(state, order.instrument, deal, now) if deal is not None and order.instrument is not None else None
+    )
     # Terminal fill-gap: book executions the venue counted but never delivered as deals so
     # position AND realized PnL converge now, not size-only at the next snapshot.
     if (gap := _reconcile_fill_gap(state, order, event, now)) is not None and order.instrument is not None:
-        position = _book_deal(state, order.instrument, gap)
+        position = _book_deal(state, order.instrument, gap, now)
         deal = deal or gap
     order = transition(state, order.client_order_id, OrderStatus.FILLED, now, update_time=event.last_update_time)
     return ApplyResult(order=order, order_change=OrderChange.FILLED, deal=deal, position=position)
@@ -410,7 +415,9 @@ def _handle_partial_fill(state: AccountState, event: OrderPartiallyFilledEvent,
         if event.fill is not None
         else None
     )
-    position = _book_deal(state, order.instrument, deal) if deal is not None and order.instrument is not None else None
+    position = (
+        _book_deal(state, order.instrument, deal, now) if deal is not None and order.instrument is not None else None
+    )
     # a pending cancel/update is resolved by the venue separately — don't disturb its status
     pending = order.status.is_pending
     if pending:
@@ -460,7 +467,7 @@ def _handle_deal(state: AccountState, event: DealEvent, now: np.datetime64) -> A
         pos = state.ensure_position(order.instrument)
         pos.update_position_by_deal(deal, state.conversion_rate(order.instrument), realize_only=True)
         return ApplyResult(deal=deal, position=pos)
-    return ApplyResult(deal=deal, position=_book_deal(state, order.instrument, deal))
+    return ApplyResult(deal=deal, position=_book_deal(state, order.instrument, deal, now))
 
 
 def _handle_updated(state: AccountState, event: OrderUpdatedEvent, now: np.datetime64) -> ApplyResult:

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/core/account_manager/state.py

@@ -69,6 +69,7 @@ class AccountState:
         "_applied_funding_buckets",
         "_balance_push_as_of",
         "_position_reconcile_as_of",
+        "_position_deal_booked_at",
     )
 
     def __init__(self, exchange: str, base_currency: str, *, terminal_history_size: int = 10_000):
@@ -117,6 +118,11 @@ class AccountState:
         # - watermark: snapshot reconciled the size up to this venue time; a deal at/under it is
         #   already in that size → reducer records but doesn't re-book it
         self._position_reconcile_as_of: dict[Instrument, np.datetime64] = {}
+        # - local clock of the most recent deal booked into the size, per instrument. A position
+        #   snapshot requested before it cannot contain that deal, so it must not overwrite the
+        #   size. Same domain as AccountSnapshot.as_of, which both connectors stamp before the
+        #   fetch (ccxt connector.py:1708, lighter connector.py:487).
+        self._position_deal_booked_at: dict[Instrument, np.datetime64] = {}
 
     def __repr__(self) -> str:
         return (
@@ -179,6 +185,12 @@ class AccountState:
     def get_balance_push_as_of(self, currency: str) -> np.datetime64 | None:
         return self._balance_push_as_of.get(currency)
 
+    def get_position_deal_booked_at(self, instrument: Instrument) -> np.datetime64 | None:
+        return self._position_deal_booked_at.get(instrument)
+
+    def mark_position_deal_booked(self, instrument: Instrument, at: np.datetime64) -> None:
+        self._position_deal_booked_at[instrument] = at
+
     def get_transition_counts(self) -> dict[str, int]:
         """Audit counter snapshot: status.value -> number of transitions into it."""
         return dict(self._transition_counts)
@@ -457,9 +469,7 @@ class AccountState:
                 f"[{self.exchange}] reconcile: position <y>{snapshot.instrument}</y> from snapshot -> "
                 f"size {existing.quantity}->{snapshot.quantity} avg {existing.position_avg_price}->{snapshot.position_avg_price}"
             )
-            existing.reconcile_size(
-                snapshot.quantity, snapshot.position_avg_price, timestamp=snapshot.last_update_time
-            )
+            existing.reconcile_size(snapshot.quantity, snapshot.position_avg_price, timestamp=snapshot.last_update_time)
 
         # external margins first, so the mark refresh below skips recalculating them
         if snapshot._maint_margin_external:

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/core/basics.py

@@ -10,9 +10,10 @@ from typing import Any, Literal, TypeAlias
 import numpy as np
 import pandas as pd
 
+from qubx import logger
 from qubx.core.exceptions import QueueTimeout
 from qubx.core.series import Bar, OrderBook, Quote, Trade, time_as_nsec
-from qubx.core.utils import prec_ceil, prec_floor, time_delta_to_str, time_to_str
+from qubx.core.utils import add_in_lots, is_lot_multiple, prec_ceil, prec_floor, time_delta_to_str, time_to_str
 from qubx.utils.clock import start_clock_discipline, time_now
 from qubx.utils.misc import Stopwatch
 from qubx.utils.time import to_timedelta
@@ -789,6 +790,25 @@ def resolve_reduce_only(options: dict[str, Any]) -> bool | None:
     return None
 
 
+class RejectCause(StrEnum):
+    """
+    Why a venue refused an order, cancel or update, in terms a caller can act on.
+
+    ``OrderRejectedEvent.code`` keeps the venue's own value — a ccxt exception class, a Lighter
+    numeric code — which is what a log reader wants. This is the portable reading of it, so a
+    strategy can say "give up on repeated INSUFFICIENT_MARGIN, keep retrying NOT_FILLABLE"
+    without a per-venue lookup table. Anything a connector does not map stays UNKNOWN.
+    """
+
+    INSUFFICIENT_MARGIN = "INSUFFICIENT_MARGIN"
+    NOT_FILLABLE = "NOT_FILLABLE"  # - post-only that would have crossed
+    RATE_LIMITED = "RATE_LIMITED"
+    TOO_SMALL = "TOO_SMALL"  # - below min size / min notional
+    NOT_FOUND = "NOT_FOUND"  # - cancel/update of an order the venue does not have
+    SEQUENCE = "SEQUENCE"  # - venue-ordering refusal; the connector rewrites it
+    UNKNOWN = "UNKNOWN"
+
+
 class OrderChange(StrEnum):
     """What happened to an order, paired with it on ApplyResult. Covers the cases
     order.status can't express on its own: UPDATED (status unchanged), CANCEL_REJECTED/
@@ -870,6 +890,8 @@ class Order:
     # venue/connector error code accompanying a reject (e.g. the ccxt error class name);
     # None when the reject path carries no code (synthetic reconcile rejects).
     error_code: str | None = None
+    # the portable reading of that code; UNKNOWN when the connector does not map it
+    reject_cause: RejectCause = RejectCause.UNKNOWN
     reduce_only: bool = False
     post_only: bool = False
     # Defaults to FRAMEWORK (the common case); the snapshot/external materialization
@@ -1212,9 +1234,21 @@ class Position:
         *,
         realize_only: bool = False,
     ) -> tuple[float, float]:
+        # - both operands are lot multiples, so add in whole lots: 28.2 + (-28.1) is 282 + (-281)
+        #   ticks, exactly one tick. Flooring the float sum loses a lot whenever subtraction leaves
+        #   the result a few ulp short of the grid, which is how a position reached 0.0 locally
+        #   while the venue still held one lot.
+        lot = self.instrument.lot_size
+        if not is_lot_multiple(self.quantity, lot) or not is_lot_multiple(amount, lot):
+            # - stale instrument metadata or a connector fault. Reported, then booked to the
+            #   nearest lot: dropping the deal is the worse error.
+            logger.error(
+                f"[{self.instrument.symbol}] booking {self.quantity} + {amount} is not on the "
+                f"lot grid (lot_size {lot}) — rounding to the nearest lot"
+            )
         return self.update_position(
             timestamp,
-            self.instrument.round_size_down(self.quantity + amount),
+            add_in_lots(self.quantity, amount, lot),
             exec_price,
             fee_amount,
             conversion_rate=conversion_rate,

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/core/events.py

@@ -15,6 +15,7 @@ from qubx.core.basics import (
     OrderBook,
     Position,
     Quote,
+    RejectCause,
     Trade,
 )
 
@@ -71,6 +72,7 @@ class OrderAcceptedEvent(OrderEvent):
 class OrderRejectedEvent(OrderEvent):
     reason: str
     code: str | None = None
+    cause: RejectCause = RejectCause.UNKNOWN
 
 
 @msg
@@ -137,12 +139,14 @@ class OrderUpdatedEvent(OrderEvent):
 class OrderCancelRejectedEvent(OrderEvent):
     reason: str
     code: str | None = None
+    cause: RejectCause = RejectCause.UNKNOWN
 
 
 @msg
 class OrderUpdateRejectedEvent(OrderEvent):
     reason: str
     code: str | None = None
+    cause: RejectCause = RejectCause.UNKNOWN
 
 
 @msg

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/core/utils.pyx

@@ -3,6 +3,8 @@ import numpy as np
 cimport numpy as np
 import pandas as pd
 import datetime
+from libc.float cimport DBL_EPSILON
+from libc.math cimport ceil, copysign, fabs, floor, fmax, pow, round
 
 NS = 1_000_000_000 
 
@@ -82,9 +84,46 @@ cpdef recognize_timeframe(timeframe):
     return tf
 
 
+cdef inline double _snap_tick_noise(double x) noexcept:
+    """
+    Snap x to the nearest integer when it is already within float noise of one. 0.29 * 100 is
+    28.999999999999996, which would otherwise floor to 28. The tolerance is relative because
+    float error scales with magnitude: 3.6e-15 at x=29, 3.7e-9 at x=2.9e7.
+    """
+    cdef double nearest = round(x)
+    cdef double tolerance = 16.0 * DBL_EPSILON * fmax(1.0, fabs(x))
+    if fabs(x - nearest) <= tolerance:
+        return nearest
+    return x
+
+
+# - previous implementation rounded the SCALED value to `precision` decimals before the floor.
+#   At precision 0 that window is half a lot, so prec_floor(3.7, 0) gave 4.0 and
+#   prec_ceil(3.4, 0) gave 3.0 — neither was a floor or a ceil any more.
+#   return np.sign(a) * np.true_divide(np.ceil(round(abs(a) * 10**precision, precision)), 10**precision)
+#   return np.sign(a) * np.true_divide(np.floor(round(abs(a) * 10**precision, precision)), 10**precision)
 cpdef double prec_ceil(double a, int precision):
-    return np.sign(a) * np.true_divide(np.ceil(round(abs(a) * 10**precision, precision)), 10**precision)
+    cdef double scale = pow(10.0, precision)
+    cdef double ticks = _snap_tick_noise(fabs(a) * scale)
+    return copysign(ceil(ticks) / scale, a)
 
 
 cpdef double prec_floor(double a, int precision):
-    return np.sign(a) * np.true_divide(np.floor(round(abs(a) * 10**precision, precision)), 10**precision)
+    cdef double scale = pow(10.0, precision)
+    cdef double ticks = _snap_tick_noise(fabs(a) * scale)
+    return copysign(floor(ticks) / scale, a)
+
+
+cpdef double add_in_lots(double quantity, double amount, double lot_size) noexcept:
+    """
+    Sum two lot multiples in whole lots, so a subtraction cannot land a few ulp off the grid.
+    """
+    return (round(quantity / lot_size) + round(amount / lot_size)) * lot_size
+
+
+cpdef bint is_lot_multiple(double quantity, double lot_size) noexcept:
+    """
+    True when quantity sits on the lot grid, within the float noise of one division.
+    """
+    cdef double raw = quantity / lot_size
+    return fabs(raw - round(raw)) <= 16.0 * DBL_EPSILON * fmax(1.0, fabs(raw))

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/utils/runner/textual/app.py

@@ -287,12 +287,14 @@ class TextualStrategyApp(App[None]):
                 with Vertical(id="tables-container", classes="tables-column"):
                     # Positions panel
                     self.positions_panel = Vertical(id="positions-panel", classes="side-panel")
+                    self.positions_panel.border_title = "Positions"
                     with self.positions_panel:
                         self.positions_table = PositionsTable(id="positions-table")
                         self.positions_table.setup_columns()
                         yield self.positions_table
                     # Orders panel
                     self.orders_panel = Vertical(id="orders-panel", classes="side-panel")
+                    self.orders_panel.border_title = "Orders"
                     with self.orders_panel:
                         self.orders_table = OrdersTable(id="orders-table")
                         self.orders_table.setup_columns()

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/utils/runner/textual/widgets/orders_table.py

@@ -109,6 +109,14 @@ class OrdersTable(DataTable):
             except Exception as e:
                 logger.warning(f"Failed to add order row {order_id}: {e}")
 
+        self._retitle(len(new_orders))
+
+    def _retitle(self, active_orders: int) -> None:
+        # - the border lives on the containing panel, so the count goes there
+        panel = self.parent
+        if panel is not None:
+            panel.border_title = f"Orders ({active_orders})"
+
     def _get_price_precision(self, row: dict) -> int:
         """Get price precision for formatting (default to 2 decimals)."""
         # Could be enhanced to use instrument precision if available

{qubx-3.6.2.dev1 → qubx-3.8.0}/src/qubx/utils/runner/textual/widgets/positions_table.py

@@ -142,6 +142,13 @@ class PositionsTable(DataTable):
                 logger.warning(f"Failed to add position row {pos_key}: {e}")
 
         self._sort()
+        self._retitle(sum(1 for r in sanitized_rows if r.get("qty")))
+
+    def _retitle(self, open_positions: int) -> None:
+        # - the border lives on the containing panel, so the count goes there
+        panel = self.parent
+        if panel is not None:
+            panel.border_title = f"Positions ({open_positions})"
 
     def _get_side(self, r: dict) -> str:
         leverage = r.get("leverage", 0.0)