Qubx 0.6.62__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.63__cp312-cp312-manylinux_2_39_x86_64.whl

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/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/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/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/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/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/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/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/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/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

{qubx-0.6.62.dist-info → qubx-0.6.63.dist-info}/METADATA

@@ -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.dist-info → qubx-0.6.63.dist-info}/RECORD

@@ -35,7 +35,7 @@ qubx/connectors/ccxt/utils.py,sha256=7BRmVT3hbGFbhRpJXTJ3lYX7R6VXi5aPxNYj1EjxObY
 qubx/connectors/tardis/data.py,sha256=JYkU9PTxIL4m0L2bLROzKtiiJSRbk48GDR4wnrL9ENM,30945
 qubx/connectors/tardis/utils.py,sha256=epThu9DwqbDb7BgScH6fHa_FVpKUaItOqp3JwtKGc5g,9092
 qubx/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/core/account.py,sha256=4_XskMLR9Uh-rpJBDYMrceYiGMvAZw56k1ve-unIW8w,19417
+qubx/core/account.py,sha256=jUiHczTSz8nEOv2D6rmDqesT-4okjJF0XnzhkXepmpI,19584
 qubx/core/basics.py,sha256=v86Men5OKIve93gSfqRD-6bjI0NUwt7gE1flm9WMul0,35904
 qubx/core/context.py,sha256=h2KeQnVe514VDSehjEIdl2Pv8FKjYaCOhpvJZPFFON8,24107
 qubx/core/deque.py,sha256=3PsmJ5LF76JpsK4Wp5LLogyE15rKn6EDCkNOOWT6EOk,6203
@@ -43,21 +43,21 @@ qubx/core/errors.py,sha256=LENtlgmVzxxUFNCsuy4PwyHYhkZkxuZQ2BPif8jaGmw,1411
 qubx/core/exceptions.py,sha256=11wQC3nnNLsl80zBqbE6xiKCqm31kctqo6W_gdnZkg8,581
 qubx/core/helpers.py,sha256=nZMe3HVheSkqczZq7-foPHfJ-49HJL69mBirBxynOBQ,20022
 qubx/core/initializer.py,sha256=YgTBs5LpIk6ZFdmMD8zCnJnVNcMh1oeYvt157jhwyMg,4242
-qubx/core/interfaces.py,sha256=OUv56aUNpaBn6zUgHr1k642ZwGgr_o0xb0_Uu3qmrxk,61380
+qubx/core/interfaces.py,sha256=gTC1B7jtYCP_mRVNFu9Bkp3ZCInRfOUX3bYITYYIwi0,62069
 qubx/core/loggers.py,sha256=wO6UdFasWu5bNeDkN7eRVDhHUQ2Rj3Apkzk9h2q71Rk,14128
 qubx/core/lookups.py,sha256=2UmODxDeDQqi-xHOvjm2_GckC4piKI3x4ZEf5vny8YI,18275
 qubx/core/metrics.py,sha256=SLbuG66Y3sH86tDHcdoIHovkhM-oSF5o840BRChrvCE,60849
 qubx/core/mixins/__init__.py,sha256=AMCLvfNuIb1kkQl3bhCj9jIOEl2eKcVPJeyLgrkB-rk,329
 qubx/core/mixins/market.py,sha256=f0PJTK5Y9nQkV2XWxytixFG1Oc6ihYVwlxIMraTnmms,4566
-qubx/core/mixins/processing.py,sha256=xFM6HkcucbtwQWKTmTVhxjdwVgKYcInI6fr3hnoDSRo,35252
+qubx/core/mixins/processing.py,sha256=eiZcr53LckDpU_BlHgqxSXmzirnijD568HyYgNBB9CM,35622
 qubx/core/mixins/subscription.py,sha256=V_g9wCPQ8S5SHkU-qOZ84cV5nReAUrV7DoSNAGG0LPY,10372
 qubx/core/mixins/trading.py,sha256=idfRPaqrvkfMxzu9mXr9i_xfqLee-ZAOrERxkxv6Ruo,7256
 qubx/core/mixins/universe.py,sha256=mzZJA7Me6HNFbAMGg1XOpnYCMtcFKHESTiozjaXyKXY,10100
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=DRIaH5DjiJNU7ZiH68fQE-QqM0e6ujx17bf_Uyl4WZU,982408
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=QaSbT8C0EiwfaqRY-46popWSYJC3oHPRcQRvX9_Piu8,982408
 qubx/core/series.pxd,sha256=aI5PG1hbr827xwcnSYgGMF2IBD4GvCRby_i9lrGrJdQ,4026
 qubx/core/series.pyi,sha256=wRb1_HpZC7KSTyWMi7K0BisaKSEro3LVebr8z5XzoDs,4668
 qubx/core/series.pyx,sha256=TpKMCqRrzrT0cj1pASlB7mLLgMLQZwDNC5o-QOxqhRQ,46936
-qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=dP51I7PhfJPwlZzOQ7zjEG1Ppm3iJGGPftylTrBfDAM,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=i6CRJdf197d3vp8MkaFWo5JIWEFCI_nw0m_ABv76muE,86568
 qubx/core/utils.pyi,sha256=a-wS13V2p_dM1CnGq40JVulmiAhixTwVwt0ah5By0Hc,348
 qubx/core/utils.pyx,sha256=k5QHfEFvqhqWfCob89ANiJDKNG8gGbOh-O4CVoneZ8M,1696
 qubx/data/__init__.py,sha256=ELZykvpPGWc5rX7QoNyNQwMLgdKMG8MACOByA4pM5hA,549
@@ -68,12 +68,12 @@ qubx/data/readers.py,sha256=g3hSkyKdMAVziMCgcaZadsukidECaLwHyIEtArSVDSc,66203
 qubx/data/registry.py,sha256=45mjy5maBSO6cf-0zfIRRDs8b0VDW7wHSPn43aRjv-o,3883
 qubx/data/tardis.py,sha256=O-zglpusmO6vCY3arSOgH6KUbkfPajSAIQfMKlVmh_E,33878
 qubx/emitters/__init__.py,sha256=11sYi8CHdPlQ5NLR84C2vUnMDkAqNIAmKo_SfqCMj2c,705
-qubx/emitters/base.py,sha256=RPjOib02h4l8ndZ4_Q7_BGTPA2YvITLUWpWlSrg2b6A,7984
-qubx/emitters/composite.py,sha256=8DsPIUtaJ95Oww9QTVVB6LR7Wcb6TJ-c1jIHMGuttz4,2784
-qubx/emitters/csv.py,sha256=lWl6sP0ke0j6kVlEbQsy11vSOHFudYHjWS9iPbq6kmo,3067
+qubx/emitters/base.py,sha256=71u0OKyLU9SN6yybRTC3rRorVPhRWy6_ExxQ7_jT2Cw,8758
+qubx/emitters/composite.py,sha256=JkFch4Tp5q6CaLU2nAmeZnRiVPGkFhGNvzhT255yJfI,3411
+qubx/emitters/csv.py,sha256=S-oQ84rCgP-bb2_q-FWcegACg_Ej_Ik3tXE6aJBlqOk,4963
 qubx/emitters/indicator.py,sha256=8opNUrkoLLcoTLISCMb7e5mlVZgdH5HduyrBxkA6sg4,7983
-qubx/emitters/prometheus.py,sha256=g2hgcV_G77fWVEXtoGJTUs4JLkB2FQXFzVY_x_sEBfc,8100
-qubx/emitters/questdb.py,sha256=vGi5r6JbKwwi8SpdXj_oG1FYrI-aEYLHYb633UAwNBk,5962
+qubx/emitters/prometheus.py,sha256=lZJ_Hl-AlkeWJmktxhAiEMiTIc8dTQvBpf3Ih5Fy6pE,10516
+qubx/emitters/questdb.py,sha256=Zc4Vbr9g7Pw9oRSEnPnA1ypDv6nRwUEYAOrT-FFYFos,11526
 qubx/exporters/__init__.py,sha256=7HeYHCZfKAaBVAByx9wE8DyGv6C55oeED9uUphcyjuc,360
 qubx/exporters/composite.py,sha256=c45XcMC0dsIDwOyOxxCuiyYQjUNhqPjptAulbaSqttU,2973
 qubx/exporters/formatters/__init__.py,sha256=La9rMsl3wyplza0xVyAFrUwhFyrGDIMJWmOB_boJyIg,488
@@ -103,7 +103,7 @@ qubx/notifications/composite.py,sha256=fa-rvHEn6k-Fma5N7cT-7Sk7hzVyB0KDs2ktDyoyL
 qubx/notifications/slack.py,sha256=RWsLyL4lm6tbmrTlXQo3nPlfiLVJ0vCfY5toJ9G8RWU,8316
 qubx/notifications/throttler.py,sha256=8jnymPQbrgtN1rD7REQa2sA9teSWTqkk_uT9oaknOyc,5618
 qubx/pandaz/__init__.py,sha256=6BYz6gSgxjNa7WP1XqWflYG7WIq1ppSD9h1XGR5M5YQ,682
-qubx/pandaz/ta.py,sha256=sIX9YxxB2S2nWU4vnS4rXFuEI5WSY76Ky1TFwf9RhMw,92154
+qubx/pandaz/ta.py,sha256=lTOE5TX9Qnl5kblCUelojJuC27B4wVt0MIquK3eO4DE,91635
 qubx/pandaz/utils.py,sha256=rg28KfcbWw4NelaI196OiAq0VM6DsszO5nrGSDPQFWk,23972
 qubx/resources/_build.py,sha256=XE7XNuDqfXPc2OriLobKXmPMvwa7Z8AKAD-18fnf0e4,8802
 qubx/resources/crypto-fees.ini,sha256=USvMoAyxqV9xeR223epFZqFs2PJt-k1pw3Rs0DXMQCg,1933
@@ -130,7 +130,7 @@ qubx/restorers/signal.py,sha256=7n7eeRhWGUBPbg179GxFH_ifywcl3pQJbwrcDklw0N0,1460
 qubx/restorers/state.py,sha256=I1VIN0ZcOjigc3WMHIYTNJeAAbN9YB21MDcMl04ZWmY,8018
 qubx/restorers/utils.py,sha256=We2gfqwQKWziUYhuUnjb-xo-5tSlbuHWpPQn0CEMTn0,1155
 qubx/ta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=Qmvnny0Tq_XxjtK7eqJgizdxbZGFaefIqrkLvJpT3UA,662632
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=vd_AR5Ab7Xs2_7V1Iilq45Bfciq-M_JcEnlmyy0IxaQ,662632
 qubx/ta/indicators.pxd,sha256=Goo0_N0Xnju8XGo3Xs-3pyg2qr_0Nh5C-_26DK8U_IE,4224
 qubx/ta/indicators.pyi,sha256=19W0uERft49In5bf9jkJHkzJYEyE9gzudN7_DJ5Vdv8,1963
 qubx/ta/indicators.pyx,sha256=Xgpew46ZxSXsdfSEWYn3A0Q35MLsopB9n7iyCsXTufs,25969
@@ -138,7 +138,7 @@ qubx/trackers/__init__.py,sha256=ThIP1jXaACse5hG3lZqQSlWSKYl6APxFmBHaRcVpPdU,100
 qubx/trackers/advanced.py,sha256=CONogr5hHHEwfolkegjpEz7NNk4Ruf9pOq5nKifNXVM,12761
 qubx/trackers/composite.py,sha256=Tjupx78SraXmRKkWhu8n81RkPjOgsDbXLd8yz6PhbaA,6318
 qubx/trackers/rebalancers.py,sha256=KFY7xuD4fGALiSLMas8MZ3ueRzlWt5wDT9329dlmNng,5150
-qubx/trackers/riskctrl.py,sha256=IuxccTgdEnN9lLMoYU8HURqPBqA3Wrk6NiOgL_O6rTM,35094
+qubx/trackers/riskctrl.py,sha256=O6UTk4nK7u5YaT_Sd4aSFBR3dWaxOLLzOzMoeU71hDY,35022
 qubx/trackers/sizers.py,sha256=OEK-IOuXiXXx8MkZiEsni5zPWFc3kun9AqApY0mIPTY,9527
 qubx/utils/__init__.py,sha256=FEPBtU3dhfLawBkAfm9FEUW4RuOY7pGCBfzDCtKjn9A,481
 qubx/utils/_pyxreloader.py,sha256=34kNd8kQi2ey_ZrGdVVUHbPrO1PEiHZDLEDBscIkT_s,12292
@@ -167,8 +167,8 @@ qubx/utils/runner/factory.py,sha256=eM4-Etcq-FewD2AjH_srFGzP413pm8er95KIZixXRpM,
 qubx/utils/runner/runner.py,sha256=m58a3kEwSs1xfgg_s9FwrQJ3AZV4Lf_VOmKDPQdaWH8,31518
 qubx/utils/time.py,sha256=J0ZFGjzFL5T6GA8RPAel8hKG0sg2LZXeQ5YfDCfcMHA,10055
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.62.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.62.dist-info/METADATA,sha256=bLqkQBXqzXkkcYiAJAc2B4BYKmyBJrbBB6bXxMgoRG8,4612
-qubx-0.6.62.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
-qubx-0.6.62.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.62.dist-info/RECORD,,
+qubx-0.6.63.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.63.dist-info/METADATA,sha256=RFICQLYzaB3Vk6jlGV2tCMXt71SAz4t1eVPqsmoCL3g,4612
+qubx-0.6.63.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
+qubx-0.6.63.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.63.dist-info/RECORD,,