Qubx 0.6.85__tar.gz → 0.6.88__tar.gz

{qubx-0.6.85 → qubx-0.6.88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 0.6.85
+Version: 0.6.88
 Summary: Qubx - Quantitative Trading Framework
 License-File: LICENSE
 Author: Dmitry Marienko

{qubx-0.6.85 → qubx-0.6.88}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.85"
+version = "0.6.88"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/backtester/management.py

@@ -327,10 +327,11 @@ class BacktestsResultsManager:
                 if not as_table:
                     print(_s)
 
+                dd_column = "max_dd_pct" if "max_dd_pct" in metrics else "mdd_pct"
                 if with_metrics:
                     _m_repr = (
                         pd.DataFrame.from_dict(metrics, orient="index")
-                        .T[["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]]
+                        .T[["gain", "cagr", "sharpe", "qr", dd_column, "mdd_usd", "fees", "execs"]]
                         .astype(float)
                     )
                     _m_repr = _m_repr.round(3).to_string(index=False)
@@ -345,7 +346,7 @@ class BacktestsResultsManager:
                     metrics = {
                         m: round(v, 3)
                         for m, v in metrics.items()
-                        if m in ["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]
+                        if m in ["gain", "cagr", "sharpe", "qr", dd_column, "mdd_usd", "fees", "execs"]
                     }
                     _t_rep.append(
                         {"Index": info.get("idx", ""), "Strategy": name}

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/backtester/runner.py

@@ -478,7 +478,7 @@ class SimulationRunner:
         )
 
         if self.emitter is not None:
-            self.emitter.set_time_provider(simulated_clock)
+            self.emitter.set_context(ctx)
 
         # - setup base subscription from spec
         if ctx.get_base_subscription() == DataType.NONE:

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/cli/commands.py

@@ -137,6 +137,51 @@ def ls(directory: str):
     ls_strats(directory)
 
 
+@main.command()
+@click.argument("config-file", type=Path, required=True)
+@click.option(
+    "--no-check-imports",
+    is_flag=True,
+    default=False,
+    help="Skip checking if strategy class can be imported",
+    show_default=True,
+)
+def validate(config_file: Path, no_check_imports: bool):
+    """
+    Validates a strategy configuration file without running it.
+
+    Checks for:
+    - Valid YAML syntax
+    - Required configuration fields
+    - Strategy class exists and can be imported (unless --no-check-imports)
+    - Exchange configurations are valid
+    - Simulation parameters are valid (if present)
+
+    Returns exit code 0 if valid, 1 if invalid.
+    """
+    from qubx.utils.runner.configs import validate_strategy_config
+
+    result = validate_strategy_config(config_file, check_imports=not no_check_imports)
+
+    if result.valid:
+        click.echo(click.style("✓ Configuration is valid", fg="green", bold=True))
+        if result.warnings:
+            click.echo(click.style("\nWarnings:", fg="yellow", bold=True))
+            for warning in result.warnings:
+                click.echo(click.style(f"  - {warning}", fg="yellow"))
+        raise SystemExit(0)
+    else:
+        click.echo(click.style("✗ Configuration is invalid", fg="red", bold=True))
+        click.echo(click.style("\nErrors:", fg="red", bold=True))
+        for error in result.errors:
+            click.echo(click.style(f"  - {error}", fg="red"))
+        if result.warnings:
+            click.echo(click.style("\nWarnings:", fg="yellow", bold=True))
+            for warning in result.warnings:
+                click.echo(click.style(f"  - {warning}", fg="yellow"))
+        raise SystemExit(1)
+
+
 @main.command()
 @click.argument(
     "directory",
@@ -358,7 +403,7 @@ def init(
     The generated strategy can be run immediately with:
     poetry run qubx run --config config.yml --paper
     """
-    from qubx.templates import TemplateManager, TemplateError
+    from qubx.templates import TemplateError, TemplateManager
     
     try:
         manager = TemplateManager()

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/connectors/ccxt/exchanges/hyperliquid/hyperliquid.py

@@ -8,7 +8,7 @@ from ...adapters.polling_adapter import PollingConfig, PollingToWebSocketAdapter
 from ..base import CcxtFuturePatchMixin
 
 # Constants
-FUNDING_RATE_DEFAULT_POLL_MINUTES = 5
+FUNDING_RATE_DEFAULT_POLL_MINUTES = 1
 FUNDING_RATE_HOUR_MS = 60 * 60 * 1000  # 1 hour in milliseconds
 
 

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/connectors/ccxt/handlers/funding_rate.py

@@ -71,7 +71,7 @@ class FundingRateDataHandler(BaseDataTypeHandler):
                             channel.send((instrument, DataType.FUNDING_RATE, funding_rate, False))
 
                             # Emit payment if funding interval changed
-                            if self._should_emit_payment(instrument, funding_rate):
+                            if self._should_emit_payment(instrument, funding_rate, current_time):
                                 payment = self._create_funding_payment(instrument)
                                 channel.send((instrument, DataType.FUNDING_PAYMENT, payment, False))
 
@@ -101,7 +101,7 @@ class FundingRateDataHandler(BaseDataTypeHandler):
             stream_name=name,
         )
 
-    def _should_emit_payment(self, instrument: Instrument, rate: FundingRate) -> bool:
+    def _should_emit_payment(self, instrument: Instrument, rate: FundingRate, current_time: dt_64) -> bool:
         """
         Determine if a funding payment should be emitted.
 
@@ -132,7 +132,7 @@ class FundingRateDataHandler(BaseDataTypeHandler):
             return False
 
         # Emit if next_funding_time has advanced (new funding period started)
-        if rate.next_funding_time > last_info["payment_time"]:
+        if rate.next_funding_time > last_info["payment_time"] and current_time > last_info["payment_time"]:
             # Store payment info for _create_funding_payment
             self._pending_funding_rates[f"{key}_payment"] = {
                 "rate": last_info["rate"].rate,

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/connectors/ccxt/reader.py

@@ -20,7 +20,7 @@ from .utils import ccxt_find_instrument, instrument_to_ccxt_symbol
 
 @reader("ccxt")
 class CcxtDataReader(DataReader):
-    SUPPORTED_DATA_TYPES = {"ohlc", "funding_payment"}
+    SUPPORTED_DATA_TYPES = {"ohlc"}
 
     _exchanges: dict[str, Exchange]
     _loop: AsyncThreadLoop
@@ -74,7 +74,8 @@ class CcxtDataReader(DataReader):
         if instrument is None:
             return []
 
-        _timeframe = pd.Timedelta(timeframe or "1m")
+        timeframe = timeframe or "1m"
+        _timeframe = pd.Timedelta(timeframe)
         _start, _stop = self._get_start_stop(start, stop, _timeframe)
 
         if _start > _stop:

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/core/interfaces.py

@@ -2050,7 +2050,7 @@ class IMetricEmitter:
         self,
         name: str,
         value: float,
-        tags: dict[str, str] | None = None,
+        tags: dict[str, Any] | None = None,
         timestamp: dt_64 | None = None,
         instrument: Instrument | None = None,
     ) -> None:
@@ -2092,15 +2092,16 @@ class IMetricEmitter:
         """
         pass
 
-    def set_time_provider(self, time_provider: ITimeProvider) -> None:
+    def set_context(self, context: "IStrategyContext") -> None:
         """
-        Set the time provider for the metric emitter.
+        Set the strategy context for the metric emitter.
 
-        This method is used to set the time provider that will be used to get timestamps
-        when no explicit timestamp is provided in the emit method.
+        This method is used to set the context that provides access to time and simulation state.
+        The context is used to automatically add is_live tag and get timestamps when no explicit
+        timestamp is provided in the emit method.
 
         Args:
-            time_provider: The time provider to use
+            context: The strategy context to use
         """
         pass
 

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/core/metrics.py

@@ -175,7 +175,7 @@ def cagr(returns, periods=DAILY):
 
     cumrets = (returns + 1).cumprod(axis=0)
     years = len(cumrets) / float(periods)
-    return (cumrets.iloc[-1] ** (1.0 / years)) - 1.0
+    return ((cumrets.iloc[-1] ** (1.0 / years)) - 1.0) * 100
 
 
 def calmar_ratio(returns, periods=DAILY):
@@ -747,6 +747,11 @@ class TradingSessionResult:
         """Get number of executions"""
         return len(self.executions_log)
 
+    @property
+    def turnover(self) -> float:
+        """Get average daily turnover as percentage of equity"""
+        return self.performance().get("avg_daily_turnover", 0.0)
+
     @property
     def leverage(self) -> pd.Series:
         """Get leverage over time"""
@@ -779,7 +784,7 @@ class TradingSessionResult:
             for k in [
                 "equity", "drawdown_usd", "drawdown_pct",
                 "compound_returns", "returns_daily", "returns", "monthly_returns",
-                "rolling_sharpe", "long_value", "short_value",
+                "rolling_sharpe", "long_value", "short_value", "turnover",
             ]:
                 self._metrics.pop(k, None)
             # fmt: on
@@ -1381,16 +1386,21 @@ def portfolio_metrics(
     execs = len(executions_log)
     mdd_pct = 100 * dd_data / equity.cummax() if execs > 0 else pd.Series(0, index=equity.index)
     sheet["equity"] = equity
-    sheet["gain"] = sheet["equity"].iloc[-1] - sheet["equity"].iloc[0]
-    sheet["cagr"] = cagr(returns_daily, performance_statistics_period)
     sheet["sharpe"] = sharpe_ratio(returns_daily, risk_free, performance_statistics_period)
+    sheet["cagr"] = cagr(returns_daily, performance_statistics_period)
+
+    # turnover calculation
+    symbols = list(set(portfolio_log.columns.str.split("_").str.get(0).values))
+    turnover_series = calculate_turnover(portfolio_log, symbols, equity, resample="1d")
+    sheet["turnover"] = turnover_series
+    sheet["daily_turnover"] = turnover_series.mean() if len(turnover_series) > 0 else 0.0
+
     sheet["qr"] = qr(equity) if execs > 0 else 0
-    sheet["drawdown_usd"] = dd_data
+    sheet["mdd_pct"] = max(mdd_pct)
     sheet["drawdown_pct"] = mdd_pct
+    sheet["drawdown_usd"] = dd_data
     # 25-May-2019: MDE fixed Max DD pct calculations
-    sheet["max_dd_pct"] = max(mdd_pct)
     # sheet["max_dd_pct_on_init"] = 100 * mdd / init_cash
-    sheet["mdd_usd"] = mdd
     sheet["mdd_start"] = equity.index[ddstart]
     sheet["mdd_peak"] = equity.index[ddpeak]
     sheet["mdd_recover"] = equity.index[ddrecover]
@@ -1403,12 +1413,12 @@ def portfolio_metrics(
     )
     sheet["calmar"] = calmar_ratio(returns_daily, performance_statistics_period)
     # sheet["ann_vol"] = annual_volatility(returns_daily)
-    sheet["tail_ratio"] = tail_ratio(returns_daily)
-    sheet["stability"] = stability_of_returns(returns_daily)
+    # sheet["tail_ratio"] = tail_ratio(returns_daily)
+    # sheet["stability"] = stability_of_returns(returns_daily)
     sheet["monthly_returns"] = aggregate_returns(returns_daily, convert_to="mon")
     r_m = np.mean(returns_daily)
     r_s = np.std(returns_daily)
-    sheet["var"] = var_cov_var(init_cash, r_m, r_s)
+    # sheet["var"] = var_cov_var(init_cash, r_m, r_s)
     sheet["avg_return"] = 100 * r_m
 
     # portfolio market values
@@ -1416,6 +1426,8 @@ def portfolio_metrics(
     sheet["long_value"] = mkt_value[mkt_value > 0].sum(axis=1).fillna(0)
     sheet["short_value"] = mkt_value[mkt_value < 0].sum(axis=1).fillna(0)
 
+    sheet["gain"] = sheet["equity"].iloc[-1] - sheet["equity"].iloc[0]
+    sheet["mdd_usd"] = mdd
     # total commissions
     sheet["fees"] = pft_total["Total_Commissions"].iloc[-1]
 
@@ -1423,9 +1435,10 @@ def portfolio_metrics(
     funding_columns = pft_total.filter(regex=".*_Funding")
     if not funding_columns.empty:
         total_funding = funding_columns.sum(axis=1)
-        sheet["funding_pnl"] = 100 * total_funding.iloc[-1] / init_cash  # as percentage of initial capital
-    else:
-        sheet["funding_pnl"] = 0.0
+        if total_funding.iloc[-1] != 0:
+            sheet["funding_pnl"] = 100 * total_funding.iloc[-1] / init_cash  # as percentage of initial capital
+    # else:
+    #     sheet["funding_pnl"] = 0.0
 
     # executions metrics
     sheet["execs"] = execs
@@ -1725,7 +1738,7 @@ def _tearsheet_single(
             ay = sbp(_n, 5)
             plt.plot(lev, c="c", lw=1.5, label="Leverage")
         plt.subplots_adjust(hspace=0)
-        return pd.DataFrame(report).T.round(3)
+        return pd.DataFrame(report).T.round(2)
 
 
 def calculate_leverage(
@@ -1828,6 +1841,53 @@ def calculate_pnl_per_symbol(
     return df
 
 
+def calculate_turnover(
+    portfolio_log: pd.DataFrame,
+    symbols: list[str],
+    equity: pd.Series,
+    resample: str = "1d",
+) -> pd.Series:
+    """
+    Calculate daily turnover as percentage of equity.
+
+    Turnover measures trading activity by calculating the absolute value of position changes
+    multiplied by price, then dividing by equity.
+
+    Args:
+        portfolio_log: Portfolio log dataframe with position and price columns
+        symbols: List of symbols to calculate turnover for
+        equity: Equity curve series
+        resample: Resampling period for turnover calculation (default "1d")
+
+    Returns:
+        pd.Series: Daily turnover as percentage of equity
+    """
+    position_diffs = []
+
+    for symbol in symbols:
+        pos_col = f"{symbol}_Pos"
+        price_col = f"{symbol}_Price"
+
+        if pos_col in portfolio_log.columns and price_col in portfolio_log.columns:
+            # Calculate absolute position change multiplied by price (notional value)
+            position_diff = portfolio_log[pos_col].diff().abs() * portfolio_log[price_col]
+            position_diffs.append(position_diff)
+
+    if not position_diffs:
+        return pd.Series(0, index=equity.index)
+
+    # Sum all position changes and resample to specified period
+    notional_turnover = pd.concat(position_diffs, axis=1).sum(axis=1).resample(resample).sum()
+
+    # Resample equity to match turnover frequency
+    equity_resampled = equity.resample(resample).last()
+
+    # Calculate turnover as percentage of equity
+    daily_turnover = notional_turnover.div(equity_resampled).mul(100).fillna(0)
+
+    return daily_turnover
+
+
 def chart_signals(
     result: TradingSessionResult,
     symbol: str,

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/emitters/base.py

@@ -4,13 +4,13 @@ Base Metric Emitter.
 This module provides a base implementation of IMetricEmitter that can be extended by other emitters.
 """
 
-from typing import Dict, List, Optional, Set
+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.interfaces import IAccountViewer, IMetricEmitter, IStrategyContext, ITimeProvider
+from qubx.core.interfaces import IAccountViewer, IMetricEmitter, IStrategyContext
 
 
 class BaseMetricEmitter(IMetricEmitter):
@@ -35,7 +35,7 @@ class BaseMetricEmitter(IMetricEmitter):
     }
 
     def __init__(
-        self, stats_to_emit: Optional[List[str]] = None, stats_interval: str = "1m", tags: dict[str, str] | None = None
+        self, stats_to_emit: Optional[List[str]] = None, stats_interval: str = "1m", tags: dict[str, Any] | None = None
     ):
         """
         Initialize the Base Metric Emitter.
@@ -49,18 +49,19 @@ class BaseMetricEmitter(IMetricEmitter):
         self._stats_interval = pd.Timedelta(stats_interval)
         self._default_tags = tags or {}
         self._last_emission_time = None
-        self._time_provider = None
+        self._context = None
 
-    def _merge_tags(self, tags: dict[str, str] | None = None, instrument: Instrument | None = None) -> dict[str, str]:
+    def _merge_tags(self, tags: dict[str, Any] | None = None, instrument: Instrument | None = None) -> dict[str, Any]:
         """
         Merge default tags with provided tags and instrument tags if provided.
+        Also automatically adds is_live tag based on context's simulation state.
 
         Args:
             tags: Additional tags to merge with default tags
             instrument: Optional instrument to add symbol and exchange tags from
 
         Returns:
-            Dict[str, str]: Merged tags dictionary
+            Dict[str, Any]: Merged tags dictionary
         """
         result = self._default_tags.copy()
 
@@ -70,9 +71,13 @@ class BaseMetricEmitter(IMetricEmitter):
         if instrument:
             result.update({"symbol": instrument.symbol, "exchange": instrument.exchange})
 
+        # Add is_live tag based on context's simulation state
+        if self._context is not None:
+            result["is_live"] = not self._context.is_simulation
+
         return result
 
-    def _emit_impl(self, name: str, value: float, tags: Dict[str, str], timestamp: dt_64 | None = None) -> None:
+    def _emit_impl(self, name: str, value: float, tags: Dict[str, Any], timestamp: dt_64 | None = None) -> None:
         """
         Implementation of emit to be overridden by subclasses.
 
@@ -88,7 +93,7 @@ class BaseMetricEmitter(IMetricEmitter):
         self,
         name: str,
         value: float,
-        tags: dict[str, str] | None = None,
+        tags: dict[str, Any] | None = None,
         timestamp: dt_64 | None = None,
         instrument: Instrument | None = None,
     ) -> None:
@@ -102,19 +107,19 @@ class BaseMetricEmitter(IMetricEmitter):
             timestamp: Optional timestamp for the metric (defaults to current time)
             instrument: Optional instrument to add symbol and exchange tags from
         """
-        if self._time_provider is not None and timestamp is None:
-            timestamp = self._time_provider.time()
+        if self._context is not None and timestamp is None:
+            timestamp = self._context.time()
         merged_tags = self._merge_tags(tags, instrument)
         self._emit_impl(name, float(value), merged_tags, timestamp)
 
-    def set_time_provider(self, time_provider: ITimeProvider) -> None:
+    def set_context(self, context: IStrategyContext) -> None:
         """
-        Set the time provider for the metric emitter.
+        Set the strategy context for the metric emitter.
 
         Args:
-            time_provider: The time provider to use
+            context: The strategy context to use
         """
-        self._time_provider = time_provider
+        self._context = context
 
     def emit_strategy_stats(self, context: IStrategyContext) -> None:
         """
@@ -126,6 +131,10 @@ class BaseMetricEmitter(IMetricEmitter):
         Args:
             context: The strategy context to get statistics from
         """
+        # Store context to ensure is_live tag is added
+        if self._context is None:
+            self._context = context
+
         try:
             # Get current timestamp
             current_time = context.time()

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/emitters/composite.py

@@ -85,6 +85,19 @@ class CompositeMetricEmitter(BaseMetricEmitter):
             except Exception as e:
                 logger.error(f"Error emitting signals to {emitter.__class__.__name__}: {e}")
 
+    def set_context(self, context: IStrategyContext) -> None:
+        """
+        Set the strategy context for all child emitters.
+
+        Args:
+            context: The strategy context to use
+        """
+        for emitter in self._emitters:
+            try:
+                emitter.set_context(context)
+            except Exception as e:
+                logger.error(f"Error setting context on {emitter.__class__.__name__}: {e}")
+
     def notify(self, context: IStrategyContext) -> None:
         for emitter in self._emitters:
             try:

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/emitters/csv.py

@@ -6,6 +6,7 @@ This module provides an implementation of IMetricEmitter that exports metrics to
 
 import os
 from pathlib import Path
+from typing import Any
 
 from qubx import logger
 from qubx.core.basics import Signal, dt_64
@@ -27,7 +28,7 @@ class CSVMetricEmitter(BaseMetricEmitter):
         file_path: str | None = None,
         stats_to_emit: list[str] | None = None,
         stats_interval: str = "1m",
-        tags: dict[str, str] | None = None,
+        tags: dict[str, Any] | None = None,
     ):
         """
         Initialize the CSV Metric Emitter.

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/emitters/indicator.py

@@ -5,6 +5,8 @@ This module provides the IndicatorEmitter class that can wrap around any indicat
 and automatically emit their values when there are updates.
 """
 
+from typing import Any
+
 import numpy as np
 import pandas as pd
 
@@ -43,7 +45,7 @@ class IndicatorEmitter(Indicator):
         metric_emitter: IMetricEmitter,
         metric_name: str | None = None,
         instrument: Instrument | None = None,
-        tags: dict[str, str] | None = None,
+        tags: dict[str, Any] | None = None,
         emit_on_new_item_only: bool = True,
     ):
         """
@@ -149,7 +151,7 @@ class IndicatorEmitter(Indicator):
         metric_emitter: IMetricEmitter,
         metric_name: str | None = None,
         instrument: Instrument | None = None,
-        tags: dict[str, str] | None = None,
+        tags: dict[str, Any] | None = None,
         emit_on_new_item_only: bool = True,
     ) -> "Indicator":
         """

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/emitters/inmemory.py

@@ -5,7 +5,7 @@ This module provides an implementation of IMetricEmitter that stores metrics in
 using a pandas DataFrame for easy access and analysis.
 """
 
-from typing import Optional
+from typing import Any, cast
 
 import pandas as pd
 
@@ -28,7 +28,7 @@ class InMemoryMetricEmitter(BaseMetricEmitter):
         self,
         stats_to_emit: list[str] | None = None,
         stats_interval: str = "1m",
-        tags: dict[str, str] | None = None,
+        tags: dict[str, Any] | None = None,
         max_rows: int | None = None,
     ):
         """
@@ -135,7 +135,7 @@ class InMemoryMetricEmitter(BaseMetricEmitter):
         if not self._rows:
             df = pd.DataFrame(columns=["timestamp", "name", "value", "symbol", "exchange"])
         else:
-            df = pd.DataFrame(self._rows)
+            df = pd.DataFrame(self._rows.copy())
             # Ensure correct dtypes
             df = df.astype(
                 {
@@ -163,7 +163,8 @@ class InMemoryMetricEmitter(BaseMetricEmitter):
             df = df[df["timestamp"] >= start_time]
         if end_time is not None:
             df = df[df["timestamp"] <= end_time]
-        return df
+
+        return cast(pd.DataFrame, df)
 
     def get_latest_metrics(
         self, instrument: Instrument | None = None, symbol: str | None = None, exchange: str | None = None

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/emitters/prometheus.py

@@ -4,7 +4,7 @@ Prometheus Metric Emitter.
 This module provides an implementation of IMetricEmitter that exports metrics to Prometheus.
 """
 
-from typing import Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional
 
 from prometheus_client import REGISTRY, Counter, Gauge, Summary, push_to_gateway
 
@@ -178,7 +178,7 @@ class PrometheusMetricEmitter(BaseMetricEmitter):
         self,
         name: str,
         value: float,
-        tags: dict[str, str] | None = None,
+        tags: dict[str, Any] | None = None,
         timestamp: dt_64 | None = None,
         metric_type: MetricType = "gauge",
     ) -> None:

{qubx-0.6.85 → qubx-0.6.88}/src/qubx/emitters/questdb.py

@@ -6,6 +6,7 @@ This module provides an implementation of IMetricEmitter that exports metrics to
 
 import datetime
 from concurrent.futures import ThreadPoolExecutor
+from typing import Any
 
 import pandas as pd
 from questdb.ingress import Sender
@@ -24,6 +25,8 @@ class QuestDBMetricEmitter(BaseMetricEmitter):
     This emitter sends metrics to QuestDB with custom timestamps and tags.
     """
 
+    SYMBOL_TAGS = ["symbol", "exchange", "type", "environment", "strategy"]
+
     def __init__(
         self,
         host: str = "localhost",
@@ -33,7 +36,7 @@ class QuestDBMetricEmitter(BaseMetricEmitter):
         stats_to_emit: list[str] | None = None,
         stats_interval: str = "1m",
         flush_interval: str = "5s",
-        tags: dict[str, str] | None = None,
+        tags: dict[str, Any] | None = None,
         max_workers: int = 1,
     ):
         """
@@ -143,10 +146,8 @@ class QuestDBMetricEmitter(BaseMetricEmitter):
                 return
 
             # Prepare symbols (tags) and columns (values)
-            symbols = {"metric_name": name}
-            symbols.update(tags)  # Add all tags as symbols
-
-            columns: dict = {"value": round(value, 5)}  # Add the value as a column
+            symbols = self._pop_symbols(tags)
+            columns: dict = {"metric_name": name, "value": round(value, 5), **tags}
 
             # Use the provided timestamp if available, otherwise use current time
             dt_timestamp = self._convert_timestamp(timestamp) if timestamp is not None else datetime.datetime.now()
@@ -261,11 +262,7 @@ class QuestDBMetricEmitter(BaseMetricEmitter):
 
                 # Use _merge_tags to get properly merged tags
                 merged_tags = self._merge_tags({}, signal.instrument)
-
-                symbols = {
-                    "group_name": signal.group if signal.group else "",
-                }
-                symbols.update(merged_tags)  # Add merged tags
+                symbols = self._pop_symbols(merged_tags)
 
                 columns = {
                     "signal": float(signal.signal),
@@ -277,6 +274,8 @@ class QuestDBMetricEmitter(BaseMetricEmitter):
                     "comment": signal.comment if signal.comment else "",
                     # "options": json.dumps(signal.options) if signal.options else "{}",
                     "is_service": bool(signal.is_service),
+                    "group_name": signal.group if signal.group else "",
+                    **merged_tags,
                 }
 
                 # Convert timestamp - signal.time is always dt_64, no need to check for string
@@ -287,3 +286,10 @@ class QuestDBMetricEmitter(BaseMetricEmitter):
 
         except Exception as e:
             logger.error(f"[QuestDBMetricEmitter] Failed to emit signals to QuestDB: {e}")
+
+    def _pop_symbols(self, tags: dict[str, str]) -> dict[str, str]:
+        symbols = {}
+        for symbol_name in self.SYMBOL_TAGS:
+            if symbol_name in tags:
+                symbols[symbol_name] = tags.pop(symbol_name)
+        return symbols