Qubx 3.6.0__tar.gz → 3.6.2.dev1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: Qubx
-Version: 3.6.0
+Version: 3.6.2.dev1
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx
@@ -43,7 +43,7 @@ Requires-Dist: rich<14,>=13.9.4
 Requires-Dist: scipy<2,>=1.12.0
 Requires-Dist: sortedcontainers<3,>=2.4.0
 Requires-Dist: stackprinter<1,>=0.2.10
-Requires-Dist: statsmodels<1,>=0.14.6
+Requires-Dist: statsmodels<0.15,>=0.14.6
 Requires-Dist: tabulate<1,>=0.9.0
 Requires-Dist: textual-autocomplete<5,>=4.0.0
 Requires-Dist: textual-serve<2,>=1.0.0

{qubx-3.6.0 → qubx-3.6.2.dev1}/pyproject.toml

@@ -56,7 +56,10 @@ dependencies = [
     "jinja2>=3.1.0,<4",
     "rich>=13.9.4,<14",
     "click>=8.1.7,<9",
-    "statsmodels>=0.14.6,<1",
+    # 0.15.0 (2026-08-27) ships no cp312 manylinux wheels — fresh resolutions (Docker image
+    # pip install, cibuildwheel test-install, downstream consumers) fall back to a meson sdist
+    # build that needs a compiler. Drop the <0.15 cap when 0.15.x publishes cp312 linux wheels.
+    "statsmodels>=0.14.6,<0.15",
 
     # - - - Database backends - - - 
     "pymongo>=4.6.1,<5",

{qubx-3.6.0 → qubx-3.6.2.dev1}/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.0'
-__version_tuple__ = version_tuple = (3, 6, 0)
+__version__ = version = '3.6.2.dev1'
+__version_tuple__ = version_tuple = (3, 6, 2, 'dev1')
 
 __commit_id__ = commit_id = None

{qubx-3.6.0 → qubx-3.6.2.dev1}/src/qubx/cli/commands.py

@@ -332,6 +332,9 @@ def run(
     help="Write simulation logs to a specific file path.",
     show_default=True,
 )
+@click.option(
+    "--dev", is_flag=True, default=False, help="Enable dev mode (adds ~/projects to path).", show_default=True
+)
 def simulate(
     config_file: Path,
     start: str | None,
@@ -340,6 +343,7 @@ def simulate(
     report: str | None,
     name: str | None,
     log_file: str | None,
+    dev: bool,
 ):
     """
     Simulates the strategy with the given configuration file.
@@ -347,7 +351,8 @@ def simulate(
     from qubx.utils.misc import add_project_to_system_path, logo
     from qubx.utils.runner.runner import simulate_strategy
 
-    add_project_to_system_path()
+    if dev:
+        add_project_to_system_path()  # Adds ~/projects in dev mode
     add_project_to_system_path(str(config_file.parent))
     logo()
     logger.info(f"Process PID: <g>{os.getpid()}</g>")

{qubx-3.6.0 → qubx-3.6.2.dev1}/src/qubx/cli/deploy.py

@@ -120,7 +120,12 @@ def ensure_lock_exists(output_dir: str) -> bool:
     """
     uv_lock_path = os.path.join(output_dir, "uv.lock")
     if not os.path.exists(uv_lock_path):
-        logger.warning("uv.lock not found in the zip file. Attempting to generate it.")
+        logger.warning(
+            "uv.lock not found in the zip file. Attempting to generate it. "
+            "This is a legacy release built without a shipped lock — resolving here, in the pod, "
+            "is non-hermetic: transitive deps can float to whatever is newest on PyPI at deploy "
+            "time (see issue #398). Re-release with a current qubx to ship a lock instead."
+        )
         try:
             subprocess.run(["uv", "lock"], cwd=output_dir, check=True, capture_output=True, text=True)
             return True
@@ -155,6 +160,11 @@ def setup_uv_environment(output_dir: str) -> bool:
         logger.info("Installing dependencies")
 
         install_cmd = ["uv", "sync"]
+        if os.path.exists(os.path.join(output_dir, "uv.lock")):
+            # Shipped lock is authoritative: never re-resolve in the pod
+            # (the runtime image cannot build sdists; see issue #398).
+            install_cmd.append("--frozen")
+
         if in_venv:
             # Force uv to create a new environment even if we're in an active one
             env = os.environ.copy()

{qubx-3.6.0 → qubx-3.6.2.dev1}/src/qubx/cli/release.py

@@ -4,6 +4,7 @@ import os
 import platform
 import re
 import shutil
+import tempfile
 import urllib.request
 from base64 import b64encode
 from collections import namedtuple
@@ -835,6 +836,57 @@ def _parse_uv_lock_git_commits(uv_lock_path: str) -> dict[str, str]:
     return commits
 
 
+def _lock_constraint_dependencies(uv_lock_path: str) -> list[str]:
+    """Build `name==version` constraints from the source repo's uv.lock.
+
+    The wrapper's fresh resolution must reproduce the source repo's tested
+    resolution — otherwise a same-day PyPI publish of any transitive dep changes
+    what bots run (see issue #398). Names that appear with multiple versions in
+    the lock (platform-forked resolutions) are skipped: a single == constraint
+    could make the wrapper unresolvable.
+
+    Only registry-sourced entries (`source = { registry = ... }`) are eligible.
+    Git, editable, path, directory, and URL sources are pinned by their own
+    ref / bundled wheel already — emitting an `==` constraint for them is wrong
+    and unsatisfiable, since uv can only satisfy a bare `==` constraint from an
+    index, and that exact version was never published to one. If ANY lock
+    entry for a given name is non-registry, the name is excluded entirely.
+    """
+    import toml
+
+    if not os.path.exists(uv_lock_path):
+        logger.warning(f"uv.lock not found at {uv_lock_path}")
+        return []
+
+    with open(uv_lock_path) as f:
+        lock_data = toml.load(f)
+
+    versions_by_name: dict[str, set[str]] = {}
+    non_registry_names: set[str] = set()
+    for pkg in lock_data.get("package", []):
+        name = pkg.get("name", "")
+        version = pkg.get("version", "")
+        if not name or not version:
+            continue
+        versions_by_name.setdefault(name, set()).add(version)
+        if "registry" not in pkg.get("source", {}):
+            non_registry_names.add(name)
+
+    skipped_multi = sorted(name for name, versions in versions_by_name.items() if len(versions) > 1)
+    if skipped_multi:
+        logger.debug(f"Skipping constraint-dependencies for multi-version packages: {skipped_multi}")
+
+    skipped_non_registry = sorted(non_registry_names)
+    if skipped_non_registry:
+        logger.debug(f"Skipping constraint-dependencies for non-registry-sourced packages: {skipped_non_registry}")
+
+    return sorted(
+        f"{name}=={next(iter(versions))}"
+        for name, versions in versions_by_name.items()
+        if len(versions) == 1 and name not in non_registry_names
+    )
+
+
 def _find_uv_git_checkout(commit_sha: str) -> str | None:
     """
     Find the uv git cache checkout directory for a given commit SHA.
@@ -921,6 +973,7 @@ def _generate_release_pyproject(
     plugin_deps: list[str] | None = None,
     external_deps: list[str] | None = None,
     pyproject_data: dict | None = None,
+    constraint_dependencies: list[str] | None = None,
 ) -> None:
     """
     Generate a minimal pyproject.toml for the release package.
@@ -940,6 +993,9 @@ def _generate_release_pyproject(
         plugin_deps: Plugin dependency specs to include
         external_deps: External package dependency specs (for no-code configs)
         pyproject_data: Original pyproject data for preserving index config
+        constraint_dependencies: `name==version` pins from the source repo's uv.lock,
+            written to `tool.uv.constraint-dependencies` so the wrapper's fresh
+            resolution reproduces the tested one (see issue #398)
     """
     import toml
 
@@ -986,11 +1042,22 @@ def _generate_release_pyproject(
         if index_sources:
             uv_config["sources"] = index_sources
 
+    if constraint_dependencies:
+        uv_config["constraint-dependencies"] = constraint_dependencies
+
+    # The wrapper only ever runs inside the deploy image (Dockerfile: FROM
+    # python:3.12-slim, linux/amd64) — never resolved for anything else. Pin
+    # both requires-python and the resolution environment to exactly that
+    # target so `uv lock` doesn't try (and fail) to find candidates for other
+    # Python versions/platforms; the bundled first-party wheels are
+    # cp312-linux_x86_64-only anyway. Must move together with the Dockerfile.
+    uv_config["environments"] = ["sys_platform == 'linux' and platform_machine == 'x86_64'"]
+
     release_pyproject: dict = {
         "project": {
             "name": "strategy-release",
             "version": "0.1.0",
-            "requires-python": ">=3.12",
+            "requires-python": "==3.12.*",
             "dependencies": deps,
         },
         "tool": {
@@ -1128,6 +1195,9 @@ def create_released_pack(
             for whl in sorted(wheel_files):
                 logger.info(f"  {whl}")
 
+    constraint_dependencies = _lock_constraint_dependencies(uv_lock_path)
+    logger.info(f"Constraining wrapper resolution to {len(constraint_dependencies)} pin(s) from source uv.lock")
+
     _generate_release_pyproject(
         release_dir=release_dir,
         strategy_wheel_name=strategy_wheel_name,
@@ -1135,6 +1205,7 @@ def create_released_pack(
         plugin_deps=plugin_deps,
         external_deps=external_deps,
         pyproject_data=pyproject_data,
+        constraint_dependencies=constraint_dependencies,
     )
 
     # --- Save config + metadata ---
@@ -1588,10 +1659,24 @@ def _bundle_source_overrides(
 
             logger.info(f"  Bundling {pkg_name}=={pkg_ver} from {build_cwd} ...")
             os.makedirs(wheels_dir, exist_ok=True)
+
+            # `uv build` refuses to build a project that lives inside uv's own
+            # cache dir ("The project directory `.` is inside the cache
+            # directory"), which is exactly where a cache-hit git checkout
+            # lives. Always build from a fresh temp copy — this also keeps
+            # build artifacts out of the shared uv cache checkout. `.git` is
+            # copied along with everything else: build backends that derive
+            # the version from VCS metadata (e.g. hatch-vcs, as quantkit
+            # uses) need it to produce a real version instead of "0.0.0".
+            build_tmp_root = tempfile.mkdtemp(prefix="qubx-release-build-")
             try:
+                build_copy = os.path.join(build_tmp_root, "src")
+                shutil.copytree(checkout_dir, build_copy, dirs_exist_ok=True)
+                copy_build_cwd = os.path.join(build_copy, subdir) if subdir else build_copy
+
                 result = subprocess.run(
                     ["uv", "build", "--wheel", ".", "--out-dir", wheels_dir],
-                    cwd=build_cwd,
+                    cwd=copy_build_cwd,
                     check=True,
                     capture_output=True,
                     text=True,
@@ -1608,6 +1693,7 @@ def _bundle_source_overrides(
             except subprocess.CalledProcessError as e:
                 logger.opt(colors=False).warning(f"  Failed to build wheel for {pkg_name}: {e.stderr or e}")
             finally:
+                shutil.rmtree(build_tmp_root, ignore_errors=True)
                 if cloned_locally and os.path.isdir(checkout_dir):
                     shutil.rmtree(checkout_dir, ignore_errors=True)
 

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

@@ -28,6 +28,11 @@ RTOL = 1e-9
 # under 1 cent is not a reconcilable difference. Absolute, because "1 cent" is absolute.
 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.
+MARGIN_RTOL = 5e-3
+
 
 # - Diff atoms ------------------------------------------------------------------ #
 @dataclass_transform(frozen_default=True, kw_only_default=True)
@@ -69,6 +74,10 @@ def _close_bal(a: float, b: float) -> bool:
     return abs(a - b) <= BALANCE_ABS_TOL
 
 
+def _close_margin(a: float, b: float) -> bool:
+    return abs(a - b) <= max(BALANCE_ABS_TOL, MARGIN_RTOL * max(abs(a), abs(b)))
+
+
 def _material_pos(position: Position) -> bool:
     # a position smaller than half a lot is effectively flat — never a presence diff
     return abs(position.quantity) > _qeps(position.instrument)
@@ -377,7 +386,7 @@ class Differ:
             if abs(lp.position_avg_price - sp.position_avg_price) > _peps(sp.instrument):
                 diffs.append(PositionAvgPriceMismatch(local=lp, origin=sp))
 
-            if not _close_rel(lp.maint_margin, sp.maint_margin):
+            if not _close_margin(lp.maint_margin, sp.maint_margin):
                 diffs.append(PositionMarginMismatch(local=lp, origin=sp))
 
         for inst, lp in local_pos.items():

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

@@ -26,6 +26,10 @@ from qubx.core.basics import STABLE_CURRENCIES, Balance, Deal, Instrument, Order
 # sessions. A re-delivered funding event only needs RECENT buckets to dedup against.
 _FUNDING_BUCKET_CAP: int = 4096
 
+# Snapshot balance-apply log level: a total move above this is real money (fill/funding/
+# transfer) and logs INFO; below it (incl. pure free/locked reshuffles) logs DEBUG.
+_BALANCE_LOG_ABS_TOL: float = 0.01
+
 
 @dataclass
 class VenueAccountFigures:
@@ -527,7 +531,11 @@ class AccountState:
         )
         if changed:
             old = "—" if existing is None else f"total={existing.total} free={existing.free} locked={existing.locked}"
-            logger.info(
+            # - free/locked reshuffle with total unchanged is margin mark-to-market noise
+            #   (every poll on a leveraged book); only a real total move is INFO-worthy
+            material = existing is None or abs(balance.total - existing.total) > _BALANCE_LOG_ABS_TOL
+            log = logger.info if material else logger.debug
+            log(
                 f"[{self.exchange}] reconcile: balance <y>{balance.currency}</y> from snapshot -> "
                 f"total=<g>{balance.total}</g> free={balance.free} locked={balance.locked} (was {old})"
             )

qubx-3.6.2.dev1/src/qubx/core/boot.py

@@ -0,0 +1,103 @@
+from enum import IntEnum
+
+from qubx import logger
+from qubx.core.basics import dt_64, td_64
+
+
+class BootPhase(IntEnum):
+    BLOCKED = -1
+    WAIT_READY = 0
+    ON_START = 1
+    RESOLVE = 2
+    RESTORE = 3
+    WARMUP_FINISHED = 4
+    BOOT_FIT = 5
+    TRADING = 6
+
+
+class BootStateMachine:
+    """Live-boot phase bookkeeping: current phase, boot-fit retry policy, health gauges.
+
+    Pure state — the ProcessingManager drives transitions and executes side effects
+    (see _advance_boot). BLOCKED is sticky for trading; a later successful fit releases
+    it (record_fit_success), a late account snapshot releases WAIT_READY (caller-side).
+    """
+
+    def __init__(self, health_monitor, *, fit_max_attempts: int = 3, fit_retry_delay: td_64 = td_64(60, "s")) -> None:
+        self.phase = BootPhase.WAIT_READY
+        self.blocked_reason: str | None = None
+        self.fit_attempts = 0
+        self._health = health_monitor
+        self._fit_max_attempts = fit_max_attempts
+        self._fit_retry_delay = fit_retry_delay
+        self._next_fit_attempt: dt_64 | None = None
+        self._sync_alerted = False
+
+    @property
+    def is_trading(self) -> bool:
+        return self.phase == BootPhase.TRADING
+
+    @property
+    def is_blocked(self) -> bool:
+        return self.phase == BootPhase.BLOCKED
+
+    def advance(self, phase: BootPhase) -> None:
+        if phase == self.phase:
+            return
+        logger.info(f"<yellow>boot</yellow> :: {self.phase.name} -> <green>{phase.name}</green>")
+        self.phase = phase
+        self._gauge("boot.state", float(phase))
+
+    def account_sync_alert(self) -> None:
+        if self._sync_alerted:
+            return
+        self._sync_alerted = True
+        self._gauge("boot.account_sync_blocked", 1.0)
+        logger.warning("<yellow>Boot blocked: initial account snapshot not applied — holding until synced</yellow>")
+
+    def account_synced(self) -> None:
+        if not self._sync_alerted:
+            return
+        self._sync_alerted = False
+        self._gauge("boot.account_sync_blocked", 0.0)
+
+    def fit_attempt_allowed(self, now: dt_64) -> bool:
+        if self.phase != BootPhase.BOOT_FIT:
+            return False
+        return self._next_fit_attempt is None or now >= self._next_fit_attempt
+
+    def record_fit_attempt(self) -> None:
+        self.fit_attempts += 1
+        self._gauge("boot.fit_attempts", float(self.fit_attempts))
+
+    def record_fit_failure(self, now: dt_64) -> None:
+        if self.is_blocked:
+            return
+        if self.fit_attempts >= self._fit_max_attempts:
+            self.blocked_reason = "boot fit failed"
+            self.advance(BootPhase.BLOCKED)
+            self._gauge("boot.fit_failed", 1.0)
+            logger.error(
+                f"<red>Boot fit failed after {self.fit_attempts} attempts — trading blocked, "
+                "book unreconciled; a later successful fit will unblock</red>"
+            )
+        else:
+            self._next_fit_attempt = now + self._fit_retry_delay
+            logger.warning(
+                f"<yellow>Boot fit failed (attempt {self.fit_attempts}/{self._fit_max_attempts}) — retrying</yellow>"
+            )
+
+    def record_fit_success(self) -> None:
+        if self.is_blocked:
+            self._gauge("boot.fit_failed", 0.0)
+            self.blocked_reason = None
+        self.advance(BootPhase.TRADING)
+
+    def record_warmup_finished_failure(self) -> None:
+        self._gauge("boot.warmup_finished_failed", 1.0)
+
+    def _gauge(self, name: str, value: float) -> None:
+        try:
+            self._health.record_gauge(name, value)
+        except Exception:
+            logger.exception(f"failed to record {name} gauge")

{qubx-3.6.0 → qubx-3.6.2.dev1}/src/qubx/core/fit_executor.py

@@ -47,11 +47,14 @@ class FitCommitData:
     order (they run on the ProcessorThread, where the fit-thread interception no
     longer triggers, so each takes today's normal path). ``signals`` are the
     fit-emitted signals, drained into the normal pipeline in emission order.
+    ``error`` carries whatever made the fit fail (strategy raise or framework raise):
+    the ProcessorThread latches ``is_on_fit_called`` only when it is None.
     """
 
     ops: tuple[Callable[[], None], ...] = ()
     signals: tuple[Signal, ...] = ()
     duration_s: float = 0.0
+    error: BaseException | None = None
 
 
 class FitCycleState:

{qubx-3.6.0 → qubx-3.6.2.dev1}/src/qubx/core/initializer.py

@@ -37,6 +37,7 @@ class BasicStrategyInitializer(IStrategyInitializer):
     default_instrument_leverage: float | None = None
     start_time_finder: StartTimeFinderProtocol | None = None
     mismatch_resolver: StateResolverProtocol | None = None
+    _fit_on_start: bool = False
     auto_subscribe: bool | None = None
     simulation: bool | None = None
     subscription_warmup: dict[Any, str] | None = None
@@ -131,6 +132,12 @@ class BasicStrategyInitializer(IStrategyInitializer):
     def set_state_resolver(self, resolver: StateResolverProtocol) -> None:
         self.mismatch_resolver = resolver
 
+    def set_fit_on_start(self, enabled: bool = True) -> None:
+        self._fit_on_start = enabled
+
+    def get_fit_on_start(self) -> bool:
+        return self._fit_on_start
+
     def set_config(self, key: str, value: Any) -> None:
         self.config[key] = value
 

{qubx-3.6.0 → qubx-3.6.2.dev1}/src/qubx/core/interfaces.py

@@ -2311,6 +2311,22 @@ class IStrategyInitializer:
         """
         ...
 
+    def set_fit_on_start(self, enabled: bool = True) -> None:
+        """
+        Force the first on_fit to run in the live context even when a warmup-sim fit ran.
+
+        The warmup simulation fits against sim state; strategies that reconcile positions
+        through their tracker on fit (e.g. buffered trackers) need the first fit to run
+        live, against live positions. Opting in guarantees exactly one live fit after
+        on_warmup_finished and replaces calling ctx.trigger_fit() there (doing both
+        double-fits). No-op when no warmup sim runs — the first fit is live anyway.
+        """
+        ...
+
+    def get_fit_on_start(self) -> bool:
+        """Whether the first on_fit is forced to run in the live context (default False)."""
+        ...
+
     def set_config(self, key: str, value: Any) -> None:
         """
         Set an additional configuration value.