Qubx 0.6.62__tar.gz → 0.6.63__tar.gz

{qubx-0.6.62 → qubx-0.6.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Qubx
-Version: 0.6.62
+Version: 0.6.63
 Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com

{qubx-0.6.62 → qubx-0.6.63}/pyproject.toml

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

{qubx-0.6.62 → qubx-0.6.63}/src/qubx/core/account.py

@@ -112,10 +112,12 @@ class BasicAccountProcessor(IAccountProcessor):
         return {s: self.get_leverage(s) for s in self._positions.keys()}
 
     def get_net_leverage(self, exchange: str | None = None) -> float:
-        return sum(self.get_leverages(exchange).values())
+        leverages = self.get_leverages(exchange).values()
+        return sum(lev for lev in leverages if lev is not None and not np.isnan(lev))
 
     def get_gross_leverage(self, exchange: str | None = None) -> float:
-        return sum(map(abs, self.get_leverages(exchange).values()))
+        leverages = self.get_leverages(exchange).values()
+        return sum(abs(lev) for lev in leverages if lev is not None and not np.isnan(lev))
 
     ########################################################
     # Margin information

{qubx-0.6.62 → qubx-0.6.63}/src/qubx/core/interfaces.py

@@ -1935,6 +1935,26 @@ class IMetricEmitter:
         """
         pass
 
+    def emit_signals(
+        self,
+        time: dt_64,
+        signals: list[Signal],
+        account: "IAccountViewer",
+        target_positions: list["TargetPosition"] | None = None,
+    ) -> None:
+        """
+        Emit signals to the monitoring system.
+
+        This method is called to emit trading signals for monitoring and analysis purposes.
+
+        Args:
+            time: Timestamp when the signals were generated
+            signals: List of signals to emit
+            account: Account viewer to get account information like total capital, leverage, etc.
+            target_positions: Optional list of target positions generated from the signals
+        """
+        pass
+
 
 class IStrategyLifecycleNotifier:
     """Interface for notifying about strategy lifecycle events."""

{qubx-0.6.62 → qubx-0.6.63}/src/qubx/core/mixins/processing.py

@@ -334,13 +334,6 @@ class ProcessingManager(IProcessingManager):
                     self._instruments_in_init_stage.remove(instr)
                     logger.info(f"Switching tracker for <g>{instr}</g> back to defined position tracker")
 
-        # - log all signals
-        self._logging.save_signals(signals)
-
-        # - export signals if exporter is specified
-        if self._exporter is not None and signals:
-            self._exporter.export_signals(self._time_provider.time(), signals, self._account)
-
         return _std_signals, _init_signals, _cancel_init_stage_instruments_tracker
 
     def __process_signals(self, signals: list[Signal]):
@@ -372,6 +365,19 @@ class ProcessingManager(IProcessingManager):
                 self._context, self.__preprocess_and_log_target_positions(_targets_from_trackers)
             )
 
+        # - log all signals and export signals if exporter is specified after processing because trackers can modify the signals
+        self._logging.save_signals(signals)
+
+        # - export signals if exporter is specified
+        if self._exporter is not None and signals:
+            self._exporter.export_signals(self._time_provider.time(), signals, self._account)
+
+        # - emit signals to metric emitters if available
+        if self._context.emitter is not None and signals:
+            self._context.emitter.emit_signals(
+                self._time_provider.time(), signals, self._account, _targets_from_trackers
+            )
+
     def __invoke_on_fit(self) -> None:
         with self._health_monitor("ctx.on_fit"):
             try:

{qubx-0.6.62 → qubx-0.6.63}/src/qubx/emitters/base.py

@@ -9,8 +9,8 @@ from typing import Dict, List, Optional, Set
 import pandas as pd
 
 from qubx import logger
-from qubx.core.basics import Instrument, dt_64
-from qubx.core.interfaces import IMetricEmitter, IStrategyContext, ITimeProvider
+from qubx.core.basics import Instrument, Signal, TargetPosition, dt_64
+from qubx.core.interfaces import IAccountViewer, IMetricEmitter, IStrategyContext, ITimeProvider
 
 
 class BaseMetricEmitter(IMetricEmitter):
@@ -182,6 +182,27 @@ class BaseMetricEmitter(IMetricEmitter):
         except Exception as e:
             logger.error(f"[BaseMetricEmitter] Failed to emit strategy stats: {e}")
 
+    def emit_signals(
+        self,
+        time: dt_64,
+        signals: list["Signal"],
+        account: "IAccountViewer",
+        target_positions: list["TargetPosition"] | None = None,
+    ) -> None:
+        """
+        Emit signals to the monitoring system.
+
+        Base implementation does nothing - subclasses should override this method
+        to implement specific signal emission logic.
+
+        Args:
+            time: Timestamp when the signals were generated
+            signals: List of signals to emit
+            account: Account viewer to get account information like total capital, leverage, etc.
+            target_positions: Optional list of target positions generated from the signals
+        """
+        pass
+
     def notify(self, context: IStrategyContext) -> None:
         """
         Notify the metric emitter of a time update.

{qubx-0.6.62 → qubx-0.6.63}/src/qubx/emitters/composite.py

@@ -7,8 +7,8 @@ This module provides a composite implementation of IMetricEmitter that delegates
 from typing import Dict, List, Optional
 
 from qubx import logger
-from qubx.core.basics import dt_64
-from qubx.core.interfaces import IMetricEmitter, IStrategyContext
+from qubx.core.basics import Signal, dt_64
+from qubx.core.interfaces import IAccountViewer, IMetricEmitter, IStrategyContext
 from qubx.emitters.base import BaseMetricEmitter
 
 
@@ -70,6 +70,21 @@ 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:
+        """
+        Emit signals to all configured emitters.
+
+        Args:
+            time: Timestamp when the signals were generated
+            signals: List of signals to emit
+            account: Account viewer to get account information
+        """
+        for emitter in self._emitters:
+            try:
+                emitter.emit_signals(time, signals, account)
+            except Exception as e:
+                logger.error(f"Error emitting signals to {emitter.__class__.__name__}: {e}")
+
     def notify(self, context: IStrategyContext) -> None:
         for emitter in self._emitters:
             try:

{qubx-0.6.62 → qubx-0.6.63}/src/qubx/emitters/csv.py

@@ -8,7 +8,8 @@ import os
 from pathlib import Path
 
 from qubx import logger
-from qubx.core.basics import dt_64
+from qubx.core.basics import Signal, dt_64
+from qubx.core.interfaces import IAccountViewer
 from qubx.emitters.base import BaseMetricEmitter
 from qubx.utils.ntp import time_now
 
@@ -81,3 +82,44 @@ class CSVMetricEmitter(BaseMetricEmitter):
                 f.write(f"{str(current_timestamp)},{name},{value},{tags_str}\n")
         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:
+        """
+        Emit signals to CSV file.
+
+        Args:
+            time: Timestamp when the signals were generated
+            signals: List of signals to emit
+            account: Account viewer to get account information
+        """
+        if not signals:
+            return
+
+        try:
+            # Create a signals-specific CSV file
+            signals_file_path = self._file_path.parent / f"signals_{self._file_path.stem}.csv"
+
+            # Check if file exists, if not create with headers
+            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"
+                    )
+
+            # Write each signal to the CSV file
+            for signal in signals:
+                signal_time = str(signal.time) if hasattr(signal.time, "__str__") else str(time)
+                price = signal.price if signal.price is not None else ""
+                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 ""
+
+                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.group},{signal.comment},{signal.is_service}\n"
+                    )
+
+        except Exception as e:
+            logger.error(f"[CSVMetricEmitter] Failed to emit signals: {e}")

{qubx-0.6.62 → qubx-0.6.63}/src/qubx/emitters/prometheus.py

@@ -9,8 +9,8 @@ from typing import Dict, List, Literal, Optional
 from prometheus_client import REGISTRY, Counter, Gauge, Summary, push_to_gateway
 
 from qubx import logger
-from qubx.core.basics import dt_64
-from qubx.core.interfaces import IStrategyContext
+from qubx.core.basics import Signal, dt_64
+from qubx.core.interfaces import IAccountViewer, IStrategyContext
 from qubx.emitters.base import BaseMetricEmitter
 
 # Define metric types
@@ -220,3 +220,58 @@ class PrometheusMetricEmitter(BaseMetricEmitter):
                 )
             except Exception as e:
                 logger.error(f"[PrometheusMetricEmitter] Failed to push metrics to gateway: {e}")
+
+    def emit_signals(self, time: dt_64, signals: list[Signal], account: IAccountViewer) -> None:
+        """
+        Emit signals as Prometheus metrics.
+
+        Args:
+            time: Timestamp when the signals were generated
+            signals: List of signals to emit
+            account: Account viewer to get account information
+        """
+        if not signals:
+            return
+
+        try:
+            for signal in signals:
+                # Create labels for the signal
+                labels = {
+                    "symbol": signal.instrument.symbol,
+                    "exchange": signal.instrument.exchange,
+                    "group": signal.group if signal.group else "default",
+                    "is_service": str(signal.is_service).lower(),
+                }
+
+                # Emit the signal value as a gauge
+                gauge = self._get_or_create_gauge("signal_value", labels)
+                gauge.labels(**labels).set(signal.signal)
+
+                # Emit price-related metrics if available
+                if signal.price is not None:
+                    price_gauge = self._get_or_create_gauge("signal_price", labels)
+                    price_gauge.labels(**labels).set(signal.price)
+
+                if signal.stop is not None:
+                    stop_gauge = self._get_or_create_gauge("signal_stop", labels)
+                    stop_gauge.labels(**labels).set(signal.stop)
+
+                if signal.take is not None:
+                    take_gauge = self._get_or_create_gauge("signal_take", labels)
+                    take_gauge.labels(**labels).set(signal.take)
+
+                if signal.reference_price is not None:
+                    ref_price_gauge = self._get_or_create_gauge("signal_reference_price", labels)
+                    ref_price_gauge.labels(**labels).set(signal.reference_price)
+
+            # Push to gateway if configured
+            if self._pushgateway_url:
+                try:
+                    push_to_gateway(
+                        self._pushgateway_url, job=f"{self._namespace}_{self._strategy_name}", registry=self._registry
+                    )
+                except Exception as e:
+                    logger.error(f"[PrometheusMetricEmitter] Failed to push signal metrics to gateway: {e}")
+
+        except Exception as e:
+            logger.error(f"[PrometheusMetricEmitter] Failed to emit signals: {e}")

{qubx-0.6.62 → qubx-0.6.63}/src/qubx/emitters/questdb.py

@@ -11,9 +11,10 @@ import pandas as pd
 from questdb.ingress import Sender
 
 from qubx import logger
-from qubx.core.basics import dt_64
-from qubx.core.interfaces import IStrategyContext
+from qubx.core.basics import Signal, TargetPosition, dt_64
+from qubx.core.interfaces import IAccountViewer, IStrategyContext
 from qubx.emitters.base import BaseMetricEmitter
+from qubx.utils.questdb import QuestDBClient
 
 
 class QuestDBMetricEmitter(BaseMetricEmitter):
@@ -28,6 +29,7 @@ class QuestDBMetricEmitter(BaseMetricEmitter):
         host: str = "localhost",
         port: int = 9000,
         table_name: str = "qubx_metrics",
+        signals_table_name: str = "qubx_signals",
         stats_to_emit: list[str] | None = None,
         stats_interval: str = "1m",
         flush_interval: str = "5s",
@@ -41,6 +43,7 @@ class QuestDBMetricEmitter(BaseMetricEmitter):
             host: QuestDB server host
             port: QuestDB server port
             table_name: Name of the table to store metrics in
+            signals_table_name: Name of the table to store signals in
             stats_to_emit: Optional list of specific stats to emit
             stats_interval: Interval for emitting strategy stats (default: "1m")
             tags: Dictionary of default tags/labels to include with all metrics
@@ -54,12 +57,16 @@ class QuestDBMetricEmitter(BaseMetricEmitter):
         self._host = host
         self._port = port
         self._table_name = table_name
+        self._signals_table_name = signals_table_name
         self._conn_str = f"http::addr={host}:{port};"
         self._flush_interval = pd.Timedelta(flush_interval)
         self._sender = self._try_get_sender()
         self._last_flush = None
         self._executor = ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="questdb_emitter")
 
+        # Create signals table if it doesn't exist
+        self._ensure_signals_table_exists()
+
     def notify(self, context: IStrategyContext) -> None:
         super().notify(context)
 
@@ -158,3 +165,125 @@ class QuestDBMetricEmitter(BaseMetricEmitter):
             logger.error(f"[QuestDBMetricEmitter] Failed to connect to QuestDB: {e}")
             _sender = None
         return _sender
+
+    def _ensure_signals_table_exists(self) -> None:
+        """Ensure the signals table exists with the correct schema."""
+        try:
+            # Use the PostgreSQL interface (port 8812) for DDL operations
+            client = QuestDBClient(host=self._host, port=8812)
+
+            create_table_sql = f"""
+            CREATE TABLE IF NOT EXISTS {self._signals_table_name} (
+                timestamp TIMESTAMP,
+                symbol SYMBOL,
+                exchange SYMBOL,
+                signal DOUBLE,
+                price DOUBLE,
+                stop DOUBLE,
+                take DOUBLE,
+                reference_price DOUBLE,
+                target_leverage DOUBLE,
+                group_name SYMBOL,
+                comment STRING,
+                is_service BOOLEAN
+            ) TIMESTAMP(timestamp) PARTITION BY DAY;
+            """
+
+            client.execute(create_table_sql)
+            logger.info(f"[QuestDBMetricEmitter] Ensured signals table '{self._signals_table_name}' exists")
+        except Exception as e:
+            logger.error(f"[QuestDBMetricEmitter] Failed to create signals table: {e}")
+
+    def emit_signals(
+        self,
+        time: dt_64,
+        signals: list[Signal],
+        account: IAccountViewer,
+        target_positions: list[TargetPosition] | None = None,
+    ) -> None:
+        """
+        Emit signals to QuestDB.
+
+        Args:
+            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 or self._sender is None:
+            return
+
+        try:
+            # Submit the signals emission to the thread pool
+            self._executor.submit(self._emit_signals_to_questdb, time, signals, account, target_positions)
+        except Exception as e:
+            logger.error(f"[QuestDBMetricEmitter] Failed to queue signals emission: {e}")
+
+    def _emit_signals_to_questdb(
+        self,
+        time: dt_64,
+        signals: list[Signal],
+        account: IAccountViewer,
+        target_positions: list[TargetPosition] | None = None,
+    ) -> None:
+        """
+        Send signals to QuestDB in a background thread.
+
+        Args:
+            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 self._sender is None:
+            return
+
+        try:
+            # Get total capital for leverage calculations
+            total_capital = account.get_total_capital()
+
+            # Create a mapping of instruments to target positions for easier lookup
+            target_positions_map = {}
+
+            if target_positions:
+                for target in target_positions:
+                    target_positions_map[target.instrument] = target
+
+            for signal in signals:
+                # Get target leverage for this instrument if available
+                target_leverage = None
+                if signal.instrument in target_positions_map:
+                    target = target_positions_map[signal.instrument]
+                    # Use signal.reference_price for notional value calculation
+                    if signal.reference_price is not None and total_capital > 0:
+                        notional_value = abs(target.target_position_size * signal.reference_price)
+                        target_leverage = (notional_value / total_capital) * 100
+
+                # 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
+
+                columns = {
+                    "signal": float(signal.signal),
+                    "price": float(signal.price) if signal.price is not None else None,
+                    "stop": float(signal.stop) if signal.stop is not None else None,
+                    "take": float(signal.take) if signal.take is not None else None,
+                    "reference_price": float(signal.reference_price) if signal.reference_price is not None else None,
+                    "target_leverage": float(target_leverage) if target_leverage is not None else None,
+                    "comment": signal.comment if signal.comment else "",
+                    # "options": json.dumps(signal.options) if signal.options else "{}",
+                    "is_service": bool(signal.is_service),
+                }
+
+                # Convert timestamp - signal.time is always dt_64, no need to check for string
+                dt_timestamp = self._convert_timestamp(time)
+
+                # Send the row to QuestDB
+                self._sender.row(self._signals_table_name, symbols=symbols, columns=columns, at=dt_timestamp)
+
+        except Exception as e:
+            logger.error(f"[QuestDBMetricEmitter] Failed to emit signals to QuestDB: {e}")

{qubx-0.6.62 → qubx-0.6.63}/src/qubx/pandaz/ta.py

@@ -1611,28 +1611,18 @@ def choppiness(
     match identification:
         case "mid":
             f0[(ci > lower) & (ci < upper)] = 0
-            f0[(ci > upper) & (ci.shift(1) <= upper)] = 1
-            f0[(ci < lower) & (ci.shift(1) >= lower)] = -1
+            f0[ci > upper] = 1
+            f0[ci < lower] = -1
         case "strong":
-            f0[(ci > lower) & (ci.shift(1) <= lower)] = 1
-            f0[(ci < lower) & (ci.shift(1) >= lower)] = 0
+            f0[ci > lower] = 1
+            f0[ci < lower] = 0
         case "weak":
-            f0[(ci > upper) & (ci.shift(1) <= upper)] = 1
-            f0[(ci < lower) & (ci.shift(1) >= lower)] = 0
+            f0[ci > upper] = 1
+            f0[ci < lower] = 0
         case _:
             raise ValueError(f"Invalid identification: {identification}")
 
-    # f0 = pd.Series(np.nan, ci.index, dtype=bool)
-    # f0[ci >= upper] = True
-    # f0[ci <= lower] = False
-    # return f0.ffill().fillna(False)
-
-    # f0 = pd.Series(np.nan, ci.index, dtype=int)
-    # f0[(ci > upper) & (ci.shift(1) <= upper)] = +1
-    # f0[(ci < lower) & (ci.shift(1) >= lower)] = 0
-    # return f0.ffill().fillna(0)
-
-    return f0.ffill().fillna(0) if not with_raw_indicator else ci
+    return f0 if not with_raw_indicator else ci
 
 
 @njit

{qubx-0.6.62 → qubx-0.6.63}/src/qubx/trackers/riskctrl.py

@@ -84,15 +84,14 @@ class RiskController(PositionsTracker):
                 )
                 continue
 
-            # - calculate risk, here we need to use copy of signa to prevent modifications of original signal
-            s_copy = s.copy()
-            signal_with_risk = self._risk_calculator.calculate_risks(ctx, quote, s_copy)
+            # - calculate risk, we allow modifications of the original signal
+            signal_with_risk = self._risk_calculator.calculate_risks(ctx, quote, s)
             if signal_with_risk is None:
                 continue
 
             # - final step - calculate actual target position and check if tracker can approve it
             target = self.get_position_sizer().calculate_target_positions(ctx, [signal_with_risk])[0]
-            if self.handle_new_target(ctx, s_copy, target):
+            if self.handle_new_target(ctx, s, target):
                 targets.append(target)
 
         return targets