Qubx 1.3.3.dev2__tar.gz → 1.3.5__tar.gz

{qubx-1.3.3.dev2 → qubx-1.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.3.3.dev2
+Version: 1.3.5
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx

{qubx-1.3.3.dev2 → qubx-1.3.5}/src/qubx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.3.3.dev2'
-__version_tuple__ = version_tuple = (1, 3, 3, 'dev2')
+__version__ = version = '1.3.5'
+__version_tuple__ = version_tuple = (1, 3, 5)
 
 __commit_id__ = commit_id = None

{qubx-1.3.3.dev2 → qubx-1.3.5}/src/qubx/cli/commands.py

@@ -1060,25 +1060,6 @@ def s3_rm_cmd(path: str, recursive: bool, yes: bool):
     s3_rm(path, recursive=recursive)
 
 
-@s3.command("parquet-stats")
-@click.argument("path", type=str)
-@click.option("--per-column", is_flag=True, help="Show per-column chunk sizes for row group 0.")
-def s3_parquet_stats_cmd(path: str, per_column: bool):
-    """
-    Print parquet file-level summary and row-group size distribution.
-
-    Accepts both S3 paths (account:bucket/key) and local paths. Reads only
-    the footer, so the full file is NOT downloaded.
-
-    Examples:\n
-      qubx s3 parquet-stats r2:dvault-features/.../part-2026-03.parquet\n
-      qubx s3 parquet-stats ./local.parquet --per-column
-    """
-    from .s3 import s3_parquet_stats
-
-    s3_parquet_stats(path, per_column=per_column)
-
-
 @s3.command("cp")
 @click.argument("src", type=str)
 @click.argument("dst", type=str)

{qubx-1.3.3.dev2 → qubx-1.3.5}/src/qubx/cli/release.py

@@ -1454,16 +1454,12 @@ def _bundle_source_overrides(
                     subprocess.run(["git", "clone", git_url, checkout_dir], check=True, capture_output=True, text=True)
                     subprocess.run(["git", "checkout", commit_sha], cwd=checkout_dir, check=True, capture_output=True, text=True)
 
-            # Honor [tool.uv.sources] `subdirectory` for monorepo git sources
-            subdir = source.get("subdirectory")
-            build_cwd = os.path.join(checkout_dir, subdir) if subdir else checkout_dir
-
-            logger.info(f"  Bundling {pkg_name}=={pkg_ver} from {build_cwd} ...")
+            logger.info(f"  Bundling {pkg_name}=={pkg_ver} from {checkout_dir} ...")
             os.makedirs(wheels_dir, exist_ok=True)
             try:
                 result = subprocess.run(
                     ["uv", "build", "--wheel", ".", "--out-dir", wheels_dir],
-                    cwd=build_cwd,
+                    cwd=checkout_dir,
                     check=True,
                     capture_output=True,
                     text=True,

{qubx-1.3.3.dev2 → qubx-1.3.5}/src/qubx/cli/s3.py

@@ -109,98 +109,6 @@ def s3_cp(src: str, dst: str, recursive: bool = False) -> None:
         raise click.Abort()
 
 
-def s3_parquet_stats(path: str, per_column: bool = False) -> None:
-    """Print file-level summary + row-group size distribution for one parquet file.
-
-    Accepts either an S3 URI (``account:bucket/key``) or a local filesystem path.
-    Uses pyarrow for metadata parsing so no data pages are fetched.
-    """
-    import pyarrow.parquet as pq
-    from pyarrow.fs import LocalFileSystem
-
-    # Heuristic: an S3 URI has "account:..." where account is non-empty and
-    # contains no path separator. Fall back to local for anything else.
-    is_s3 = ":" in path and "/" not in path.split(":", 1)[0] and not path.startswith("/")
-    if is_s3:
-        try:
-            client, s3_path = S3Client.from_uri(path)
-        except ValueError as e:
-            raise click.BadParameter(str(e))
-        fs = client.fs
-        open_path = s3_path
-    else:
-        fs = LocalFileSystem()
-        open_path = path
-
-    try:
-        with fs.open_input_file(open_path) as f:
-            meta = pq.ParquetFile(f).metadata
-    except Exception as e:
-        click.echo(click.style(f"Error reading {path}: {e}", fg="red"), err=True)
-        raise click.Abort()
-
-    click.echo(click.style(f"File: {path}", fg="cyan", bold=True))
-    click.echo(f"  num_rows:       {meta.num_rows:,}")
-    click.echo(f"  num_row_groups: {meta.num_row_groups}")
-    click.echo(f"  num_columns:    {meta.num_columns}")
-    click.echo(f"  format_version: {meta.format_version}")
-    if meta.created_by:
-        click.echo(f"  created_by:     {meta.created_by}")
-
-    if meta.num_row_groups == 0:
-        return
-
-    # Parquet spec: RowGroup.total_byte_size is the SUM of uncompressed
-    # column sizes. The compressed on-disk size is the sum of
-    # ColumnChunk.total_compressed_size across columns.
-    rows: list[int] = []
-    per_rg_compressed: list[int] = []
-    per_rg_uncompressed: list[int] = []
-    compressions: set[str] = set()
-    for i in range(meta.num_row_groups):
-        rg = meta.row_group(i)
-        rows.append(rg.num_rows)
-        c_sz = 0
-        u_sz = 0
-        for c in range(rg.num_columns):
-            col = rg.column(c)
-            c_sz += col.total_compressed_size
-            u_sz += col.total_uncompressed_size
-            compressions.add(str(col.compression))
-        per_rg_compressed.append(c_sz)
-        per_rg_uncompressed.append(u_sz)
-
-    total_compressed = sum(per_rg_compressed)
-    total_uncompressed = sum(per_rg_uncompressed)
-    click.echo()
-    click.echo(click.style("Row groups:", fg="cyan", bold=True))
-    click.echo(f"  rows per rg:   min={min(rows):,}  max={max(rows):,}  avg={sum(rows)//len(rows):,}")
-    click.echo(
-        f"  cmp per rg:    min={_human_size(min(per_rg_compressed))}  "
-        f"max={_human_size(max(per_rg_compressed))}  avg={_human_size(sum(per_rg_compressed) // len(per_rg_compressed))}"
-    )
-    click.echo(f"  total:         compressed={_human_size(total_compressed)}  uncompressed={_human_size(total_uncompressed)}")
-    if total_uncompressed > 0:
-        ratio = 100 * total_compressed / total_uncompressed
-        click.echo(f"  compression:   {', '.join(sorted(compressions))}  ({ratio:.1f}% of uncompressed)")
-    else:
-        click.echo(f"  compression:   {', '.join(sorted(compressions))}")
-
-    if per_column:
-        click.echo()
-        click.echo(click.style("Columns (row group 0):", fg="cyan", bold=True))
-        rg0 = meta.row_group(0)
-        click.echo(f"  {'path':30s}  {'type':12s}  {'compressed':>11s}  {'uncompressed':>12s}   pct  compression")
-        for c in range(rg0.num_columns):
-            col = rg0.column(c)
-            pct = (100 * col.total_compressed_size / col.total_uncompressed_size) if col.total_uncompressed_size else 0.0
-            click.echo(
-                f"  {col.path_in_schema:30s}  {str(col.physical_type):12s}  "
-                f"{_human_size(col.total_compressed_size):>11s}  {_human_size(col.total_uncompressed_size):>12s}  "
-                f"{pct:5.1f}%  {col.compression}"
-            )
-
-
 def s3_accounts() -> None:
     s = get_settings()
     if not s.s3:

{qubx-1.3.3.dev2 → qubx-1.3.5}/src/qubx/core/interfaces.py

@@ -12,6 +12,7 @@ This module includes:
     - Strategy lifecycle notifiers
 """
 
+import datetime
 import inspect
 import traceback
 from dataclasses import dataclass
@@ -2790,7 +2791,7 @@ class IMetricEmitter:
 
     def emit_signals(
         self,
-        time: dt_64,
+        time: dt_64 | pd.Timestamp | datetime.datetime,
         signals: list[Signal],
         account: "IAccountViewer",
         target_positions: list["TargetPosition"] | None = None,
@@ -2810,7 +2811,7 @@ class IMetricEmitter:
 
     def emit_deals(
         self,
-        time: dt_64,
+        time: dt_64 | pd.Timestamp | datetime.datetime,
         instrument: Instrument,
         deals: list[Deal],
         account: "IAccountViewer",

{qubx-1.3.3.dev2 → qubx-1.3.5}/src/qubx/core/series.pxd

@@ -187,8 +187,9 @@ cdef class BundledSeries(TimeSeries):
     """
     Virtual series that bundles fields from multiple source TimeSeries.
     """
-    cdef dict _fields          # field_name -> TimeSeries
-    cdef list _field_names     # ordered list of field names
+    cdef dict _fields              # field_name -> TimeSeries
+    cdef list _field_names         # ordered list of field names
+    cdef long long _align_timeframe  # alignment bin (ns) for cross-source timestamp flooring
 
     cdef double _lookup_value(BundledSeries self, TimeSeries series, long long time)
     cdef TimeSeries _find_root(BundledSeries self, TimeSeries series)

{qubx-1.3.3.dev2 → qubx-1.3.5}/src/qubx/core/series.pyi

@@ -266,7 +266,14 @@ class BundledSeries(TimeSeries):
     _fields: dict[str, TimeSeries]
     _field_names: list[str]
 
-    def __init__(self, name: str, timeframe, fields: dict[str, TimeSeries], max_series_length: int | float = ...) -> None: ...
+    def __init__(
+        self,
+        name: str,
+        timeframe,
+        fields: dict[str, TimeSeries],
+        align_timeframe: str | None = ...,
+        max_series_length: int | float = ...,
+    ) -> None: ...
     def update(self, time: int, value: Any, new_item_started: bool) -> Any: ...
     def to_series(self, length: int | None = None) -> pd.DataFrame: ...
 

{qubx-1.3.3.dev2 → qubx-1.3.5}/src/qubx/core/series.pyx

@@ -126,15 +126,50 @@ cdef class Indexed:
 
     def lookup_idx(self, value, str method) -> int:
         """
-        Find value's index in series using specified method (ffill: previous index, bfill: next index)
+        Find value's index in series using specified method.
+
+        - ffill: previous index — equivalent to np.searchsorted(side='right') - 1.
+                 Returns -1 if value is below all stored items.
+        - bfill: next index — equivalent to np.searchsorted(side='left').
+                 Returns -1 if value is above all stored items.
+
+        Implementation note: this is a pure-Cython binary search over the Python
+        list `self.values`. It replaces a previous `np.searchsorted` call which
+        spent the bulk of its time in `np.asarray(list)` conversion (O(n) per
+        call) — `_wrapit` was the dominant hotspot in profiles. Element
+        comparisons here go through Python rich comparison, which is fast for
+        the int/float scalars actually stored. Behavior matches the original
+        for sorted ascending input (the only contract the rest of the codebase
+        relies on).
         """
+        cdef int n = len(self.values)
+        cdef int lo, hi, mid
         cdef int i0
+
         if method == 'ffill':
-            i0 = int(np.searchsorted(self.values, value, side='right'))
+            # - rightmost insertion point, then -1
+            lo = 0
+            hi = n
+            while lo < hi:
+                mid = (lo + hi) >> 1
+                if self.values[mid] <= value:
+                    lo = mid + 1
+                else:
+                    hi = mid
+            i0 = lo
             return max(-1, i0 - 1)
         elif method == 'bfill':
-            i0 = int(np.searchsorted(self.values, value, side='left'))
-            return -1 if i0 >= len(self.values) else i0
+            # - leftmost insertion point
+            lo = 0
+            hi = n
+            while lo < hi:
+                mid = (lo + hi) >> 1
+                if self.values[mid] < value:
+                    lo = mid + 1
+                else:
+                    hi = mid
+            i0 = lo
+            return -1 if i0 >= n else i0
         else:
             raise ValueError(f"Unsupported method {method}")
 
@@ -1845,18 +1880,26 @@ cdef class BundledSeries(TimeSeries):
         # When either vtwap or ohlcv updates, bundle gathers values and triggers spread
     """
 
-    def __init__(self, str name, timeframe, dict fields, max_series_length=INFINITY):
+    def __init__(self, str name, timeframe, dict fields, align_timeframe=None, max_series_length=INFINITY):
         """
         Args:
             name: Name of this bundled series
             timeframe: Timeframe string (e.g., "1m", "1h")
             fields: Dict mapping field names to TimeSeries
                     e.g., {"vwap": vtwap_ts, "close": close_ts}
+            align_timeframe: Optional timeframe string used to bin-align source
+                timestamps before joining (floor_t64(t, align_timeframe)).
+                Defaults to `timeframe` when None. Use this when source series
+                have timestamps offset within the same logical bar (e.g. OHLC
+                at bar-open x:00:00 vs vendor data shifted to bar-close x:14:55
+                for a 15-minute timeframe) — both floor to the same bin.
             max_series_length: Maximum number of values to store
         """
         super().__init__(name, timeframe, max_series_length)
         self._fields = fields
         self._field_names = list(fields.keys())
+        # - alignment bin: explicit align_timeframe if provided, else self.timeframe (already ns after super().__init__)
+        self._align_timeframe = recognize_timeframe(align_timeframe) if align_timeframe is not None else self.timeframe
 
         # Attach to each source series' calculation chain
         for field_name, series in fields.items():
@@ -1883,22 +1926,39 @@ cdef class BundledSeries(TimeSeries):
         return series
 
     def _initial_data_recalculate_bundled(self):
-        """Align all sources by timestamp for initial calculation."""
-        # Collect all source data as pandas Series
+        """
+        Align all sources by timestamp for initial calculation.
+
+        Each source's timestamps are floored to self._align_timeframe first, then
+        outer-joined and forward-filled so mixed-cadence sources (e.g. 15m OHLC +
+        1h OI) and offset-stamped sources (e.g. open-stamped OHLC x:00:00 +
+        close-stamped vendor x:14:55 within the same 15m bin) all land in the
+        same row. Rows where any field is still NaN after ffill are dropped —
+        this handles warm-up bars where the slow-cadence source hasn't ticked yet.
+        """
         cdef list dfs = []
         cdef str name
         cdef TimeSeries series
+        cdef long long tf_ns = self._align_timeframe
 
         for name, series in self._fields.items():
             s = series.to_series()
             if len(s) > 0:
+                # - floor each timestamp to the align bin, keep last value within each bin
+                floored = pd.DatetimeIndex(
+                    [pd.Timestamp(floor_t64(<long long> t.value, tf_ns)) for t in s.index]
+                )
+                s = s.copy()
+                s.index = floored
+                s = s[~s.index.duplicated(keep='last')]
                 dfs.append(s.rename(name))
 
         if not dfs:
             return
 
-        # Align by timestamp (inner join - only times present in all sources)
-        aligned = pd.concat(dfs, axis=1).dropna()
+        # - outer-join on floored timestamps, ffill to carry slow-cadence sources forward,
+        # - then drop leading rows where any field is still NaN (warm-up)
+        aligned = pd.concat(dfs, axis=1).sort_index().ffill().dropna()
 
         # Process each aligned row
         for t in aligned.index:

{qubx-1.3.3.dev2 → qubx-1.3.5}/src/qubx/emitters/base.py

@@ -4,10 +4,13 @@ Base Metric Emitter.
 This module provides a base implementation of IMetricEmitter that can be extended by other emitters.
 """
 
+import datetime
 from typing import Any, Dict, List, Optional, Set
 
+import pandas as pd
+
 from qubx import logger
-from qubx.core.basics import Instrument, Signal, TargetPosition, dt_64
+from qubx.core.basics import Deal, Instrument, Signal, TargetPosition, dt_64
 from qubx.core.interfaces import IAccountViewer, IMetricEmitter, IStrategyContext
 from qubx.utils.time import to_timedelta
 
@@ -199,10 +202,10 @@ class BaseMetricEmitter(IMetricEmitter):
 
     def emit_signals(
         self,
-        time: dt_64,
-        signals: list["Signal"],
-        account: "IAccountViewer",
-        target_positions: list["TargetPosition"] | None = None,
+        time: dt_64 | pd.Timestamp | datetime.datetime,
+        signals: list[Signal],
+        account: IAccountViewer,
+        target_positions: list[TargetPosition] | None = None,
     ) -> None:
         """
         Emit signals to the monitoring system.
@@ -218,6 +221,27 @@ class BaseMetricEmitter(IMetricEmitter):
         """
         pass
 
+    def emit_deals(
+        self,
+        time: dt_64 | pd.Timestamp | datetime.datetime,
+        instrument: Instrument,
+        deals: list[Deal],
+        account: IAccountViewer,
+    ) -> None:
+        """
+        Emit deals to the monitoring system.
+
+        Base implementation does nothing - subclasses should override this method
+        to implement specific deal emission logic.
+
+        Args:
+            time: Timestamp when the deals were generated
+            instrument: Instrument the deals belong to
+            deals: List of deals to emit
+            account: Account viewer to get account information like total capital, leverage, etc.
+        """
+        pass
+
     def notify(self, context: IStrategyContext) -> None:
         """
         Notify the metric emitter of a time update.

{qubx-1.3.3.dev2 → qubx-1.3.5}/src/qubx/emitters/composite.py

@@ -4,10 +4,13 @@ Composite Metric Emitter.
 This module provides a composite implementation of IMetricEmitter that delegates to multiple emitters.
 """
 
+import datetime
 from typing import Dict, List, Optional
 
+import pandas as pd
+
 from qubx import logger
-from qubx.core.basics import Deal, Instrument, Signal, dt_64
+from qubx.core.basics import Deal, Instrument, Signal, TargetPosition, dt_64
 from qubx.core.interfaces import IAccountViewer, IMetricEmitter, IStrategyContext
 from qubx.emitters.base import BaseMetricEmitter
 
@@ -70,7 +73,13 @@ class CompositeMetricEmitter(BaseMetricEmitter):
             except Exception as e:
                 logger.error(f"Error emitting strategy stats to {emitter.__class__.__name__}: {e}")
 
-    def emit_signals(self, time: dt_64, signals: list["Signal"], account: "IAccountViewer") -> None:
+    def emit_signals(
+        self,
+        time: dt_64 | pd.Timestamp | datetime.datetime,
+        signals: list[Signal],
+        account: IAccountViewer,
+        target_positions: list[TargetPosition] | None = None,
+    ) -> None:
         """
         Emit signals to all configured emitters.
 
@@ -78,14 +87,21 @@ class CompositeMetricEmitter(BaseMetricEmitter):
             time: Timestamp when the signals were generated
             signals: List of signals to emit
             account: Account viewer to get account information
+            target_positions: List of target positions (optional)
         """
         for emitter in self._emitters:
             try:
-                emitter.emit_signals(time, signals, account)
+                emitter.emit_signals(time, signals, account, target_positions)
             except Exception as e:
                 logger.error(f"Error emitting signals to {emitter.__class__.__name__}: {e}")
 
-    def emit_deals(self, time: dt_64, instrument: Instrument, deals: list[Deal], account: "IAccountViewer") -> None:
+    def emit_deals(
+        self,
+        time: dt_64 | pd.Timestamp | datetime.datetime,
+        instrument: Instrument,
+        deals: list[Deal],
+        account: IAccountViewer,
+    ) -> None:
         """
         Emit deals to all configured emitters.
 

{qubx-1.3.3.dev2 → qubx-1.3.5}/src/qubx/emitters/csv.py

@@ -4,12 +4,15 @@ CSV Metric Emitter.
 This module provides an implementation of IMetricEmitter that exports metrics to a CSV file.
 """
 
+import datetime
 import os
 from pathlib import Path
 from typing import Any
 
+import pandas as pd
+
 from qubx import logger
-from qubx.core.basics import Signal, dt_64
+from qubx.core.basics import Deal, Instrument, Signal, TargetPosition, dt_64
 from qubx.core.interfaces import IAccountViewer
 from qubx.emitters.base import BaseMetricEmitter
 from qubx.utils.ntp import time_now
@@ -84,7 +87,13 @@ class CSVMetricEmitter(BaseMetricEmitter):
         except Exception as e:
             logger.error(f"[CSVMetricEmitter] Failed to emit metric {name}: {e}")
 
-    def emit_signals(self, time: dt_64, signals: list[Signal], account: IAccountViewer) -> None:
+    def emit_signals(
+        self,
+        time: dt_64 | pd.Timestamp | datetime.datetime,
+        signals: list[Signal],
+        account: IAccountViewer,
+        target_positions: list[TargetPosition] | None = None,
+    ) -> None:
         """
         Emit signals to CSV file.
 
@@ -92,10 +101,16 @@ class CSVMetricEmitter(BaseMetricEmitter):
             time: Timestamp when the signals were generated
             signals: List of signals to emit
             account: Account viewer to get account information
+            target_positions: Optional list of target positions generated from the signals
         """
         if not signals:
             return
 
+        target_positions_map: dict[Instrument, TargetPosition] = {}
+        if target_positions:
+            for target in target_positions:
+                target_positions_map[target.instrument] = target
+
         try:
             # Create a signals-specific CSV file
             signals_file_path = self._file_path.parent / f"signals_{self._file_path.stem}.csv"
@@ -104,7 +119,8 @@ class CSVMetricEmitter(BaseMetricEmitter):
             if not signals_file_path.exists():
                 with open(signals_file_path, "w") as f:
                     f.write(
-                        "timestamp,symbol,exchange,signal,price,stop,take,reference_price,group,comment,is_service\n"
+                        "timestamp,symbol,exchange,signal,price,stop,take,reference_price,"
+                        "target_position_size,group,comment,is_service\n"
                     )
 
             # Write each signal to the CSV file
@@ -114,13 +130,58 @@ class CSVMetricEmitter(BaseMetricEmitter):
                 stop = signal.stop if signal.stop is not None else ""
                 take = signal.take if signal.take is not None else ""
                 ref_price = signal.reference_price if signal.reference_price is not None else ""
+                target = target_positions_map.get(signal.instrument)
+                target_size = target.target_position_size if target is not None else ""
 
                 with open(signals_file_path, "a") as f:
                     f.write(
                         f"{signal_time},{signal.instrument.symbol},{signal.instrument.exchange},"
-                        f"{signal.signal},{price},{stop},{take},{ref_price},"
+                        f"{signal.signal},{price},{stop},{take},{ref_price},{target_size},"
                         f"{signal.group},{signal.comment},{signal.is_service}\n"
                     )
 
         except Exception as e:
             logger.error(f"[CSVMetricEmitter] Failed to emit signals: {e}")
+
+    def emit_deals(
+        self,
+        time: dt_64 | pd.Timestamp | datetime.datetime,
+        instrument: Instrument,
+        deals: list[Deal],
+        account: IAccountViewer,
+    ) -> None:
+        """
+        Emit deals to CSV file.
+
+        Args:
+            time: Timestamp when the deals were generated
+            instrument: Instrument the deals belong to
+            deals: List of deals to emit
+            account: Account viewer to get account information
+        """
+        if not deals:
+            return
+
+        try:
+            deals_file_path = self._file_path.parent / f"deals_{self._file_path.stem}.csv"
+
+            if not deals_file_path.exists():
+                with open(deals_file_path, "w") as f:
+                    f.write(
+                        "timestamp,symbol,exchange,amount,price,aggressive,"
+                        "fee_amount,fee_currency,deal_id,order_id\n"
+                    )
+
+            with open(deals_file_path, "a") as f:
+                for deal in deals:
+                    deal_time = str(deal.time) if hasattr(deal.time, "__str__") else str(time)
+                    fee_amount = deal.fee_amount if deal.fee_amount is not None else ""
+                    fee_currency = deal.fee_currency if deal.fee_currency is not None else ""
+                    f.write(
+                        f"{deal_time},{instrument.symbol},{instrument.exchange},"
+                        f"{deal.amount},{deal.price},{deal.aggressive},"
+                        f"{fee_amount},{fee_currency},{deal.id},{deal.order_id}\n"
+                    )
+
+        except Exception as e:
+            logger.error(f"[CSVMetricEmitter] Failed to emit deals: {e}")