Qubx 0.6.0__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.1__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/__init__.py

@@ -68,10 +68,6 @@ class QubxLogConfig:
     def setup_logger(level: str | None = None, custom_formatter: Callable | None = None):
         global logger
 
-        # First, remove all existing handlers to prevent resource leaks
-        # Use a safer approach that doesn't rely on internal attributes
-        logger.remove()
-
         config = {
             "handlers": [
                 {"sink": sys.stdout, "format": "{time} - {message}"},
@@ -79,6 +75,7 @@ class QubxLogConfig:
             "extra": {"user": "someone"},
         }
         logger.configure(**config)
+        logger.remove(None)
 
         level = level or QubxLogConfig.get_log_level()
         # Add stdout handler with enqueue=True for thread/process safety

qubx/cli/release.py

@@ -406,6 +406,15 @@ def _create_metadata(stg_name: str, git_info: ReleaseInfo, release_dir: str) ->
             sort_keys=False,
         )
 
+    # Create a README.md file
+    with open(os.path.join(release_dir, "README.md"), "wt") as fs:
+        fs.write(f"# {stg_name}\n\n")
+        fs.write("## Git Info\n\n")
+        fs.write(f"Tag: {git_info.tag}\n")
+        fs.write(f"Date: {git_info.time.isoformat()}\n")
+        fs.write(f"Author: {git_info.user}\n")
+        fs.write(f"Commit: {git_info.commit}\n")
+
 
 def _modify_pyproject_toml(pyproject_path: str, package_name: str) -> None:
     """
@@ -553,7 +562,7 @@ def _get_imports(file_name: str, current_directory: str, what_to_look: list[str]
                     + ".py"
                 )
             imports.extend(_get_imports(f1, current_directory, what_to_look))
-        except Exception as e:
+        except Exception:
             pass
     return imports
 
@@ -582,11 +591,10 @@ def make_tag_in_repo(repo: Repo, strategy_name_id: str, user: str, tag: str) ->
     repo.config_writer().set_value("push", "followTags", "true").release()
 
     _tn = datetime.now()
-    ref_an = repo.create_tag(
+    _ = repo.create_tag(
         tag,
         message=f"Release of '{strategy_name_id}' at {_tn.strftime('%Y-%b-%d %H:%M:%S')} by {user}",
     )
-    # Fix: Push the tag reference properly
     repo.remote("origin").push(f"refs/tags/{tag}")
     return tag
 

qubx/core/context.py

@@ -31,6 +31,7 @@ from qubx.core.interfaces import (
     IStrategy,
     IStrategyContext,
     ISubscriptionManager,
+    ITradeDataExport,
     ITradingManager,
     IUniverseManager,
     PositionsTracker,
@@ -70,6 +71,7 @@ class StrategyContext(IStrategyContext):
 
     _thread_data_loop: Thread | None = None  # market data loop
     _is_initialized: bool = False
+    _exporter: ITradeDataExport | None = None  # Add exporter attribute
 
     def __init__(
         self,
@@ -84,6 +86,7 @@ class StrategyContext(IStrategyContext):
         config: dict[str, Any] | None = None,
         position_gathering: IPositionGathering | None = None,  # TODO: make position gathering part of the strategy
         aux_data_provider: DataReader | None = None,
+        exporter: ITradeDataExport | None = None,  # Add exporter parameter
     ) -> None:
         self.account = account
         self.strategy = self.__instantiate_strategy(strategy, config)
@@ -96,6 +99,7 @@ class StrategyContext(IStrategyContext):
         self._initial_instruments = instruments
 
         self._cache = CachedMarketDataHolder()
+        self._exporter = exporter  # Store the exporter
 
         __position_tracker = self.strategy.tracker(self)
         if __position_tracker is None:
@@ -149,6 +153,7 @@ class StrategyContext(IStrategyContext):
             cache=self._cache,
             scheduler=self._scheduler,
             is_simulation=self._data_provider.is_simulation,
+            exporter=self._exporter,  # Pass exporter to processing manager
         )
         self.__post_init__()
 

qubx/core/interfaces.py

@@ -39,6 +39,46 @@ from qubx.core.series import OHLCV, Bar, Quote
 RemovalPolicy = Literal["close", "wait_for_close", "wait_for_change"]
 
 
+class ITradeDataExport:
+    """Interface for exporting trading data to external systems."""
+
+    def export_signals(self, time: dt_64, signals: List[Signal], account: "IAccountViewer") -> None:
+        """
+        Export signals to an external system.
+
+        Args:
+            time: Timestamp when the signals were generated
+            signals: List of signals to export
+            account: Account viewer to get account information like total capital, leverage, etc.
+        """
+        pass
+
+    def export_target_positions(self, time: dt_64, targets: List[TargetPosition], account: "IAccountViewer") -> None:
+        """
+        Export target positions to an external system.
+
+        Args:
+            time: Timestamp when the target positions were generated
+            targets: List of target positions to export
+            account: Account viewer to get account information like total capital, leverage, etc.
+        """
+        pass
+
+    def export_position_changes(
+        self, time: dt_64, instrument: Instrument, price: float, account: "IAccountViewer"
+    ) -> None:
+        """
+        Export position changes to an external system.
+
+        Args:
+            time: Timestamp when the leverage change occurred
+            instrument: The instrument for which the leverage changed
+            price: Price at which the leverage changed
+            account: Account viewer to get account information like total capital, leverage, etc.
+        """
+        pass
+
+
 class IAccountViewer:
     account_id: str
 
@@ -579,9 +619,9 @@ class IUniverseManager:
             instruments: List of instruments in the universe
             skip_callback: Skip callback to the strategy
             if_has_position_then: What to do if the instrument has a position
-                - “close” (default) - close position immediatelly and remove (unsubscribe) instrument from strategy
-                - “wait_for_close” - keep instrument and it’s position until it’s closed from strategy (or risk management), then remove instrument from strategy
-                - “wait_for_change” - keep instrument and position until strategy would try to change it - then close position and remove instrument
+                - "close" (default) - close position immediatelly and remove (unsubscribe) instrument from strategy
+                - "wait_for_close" - keep instrument and it's position until it's closed from strategy (or risk management), then remove instrument from strategy
+                - "wait_for_change" - keep instrument and position until strategy would try to change it - then close position and remove instrument
         """
         ...
 
@@ -599,9 +639,9 @@ class IUniverseManager:
         Args:
             instruments: List of instruments to remove
             if_has_position_then: What to do if the instrument has a position
-                - “close” (default) - close position immediatelly and remove (unsubscribe) instrument from strategy
-                - “wait_for_close” - keep instrument and it’s position until it’s closed from strategy (or risk management), then remove instrument from strategy
-                - “wait_for_change” - keep instrument and position until strategy would try to change it - then close position and remove instrument
+                - "close" (default) - close position immediatelly and remove (unsubscribe) instrument from strategy
+                - "wait_for_close" - keep instrument and it's position until it's closed from strategy (or risk management), then remove instrument from strategy
+                - "wait_for_change" - keep instrument and position until strategy would try to change it - then close position and remove instrument
         """
         ...
 

qubx/core/mixins/processing.py

@@ -28,6 +28,7 @@ from qubx.core.interfaces import (
     IStrategyContext,
     ISubscriptionManager,
     ITimeProvider,
+    ITradeDataExport,
     IUniverseManager,
     PositionsTracker,
 )
@@ -50,6 +51,7 @@ class ProcessingManager(IProcessingManager):
     _cache: CachedMarketDataHolder
     _scheduler: BasicScheduler
     _universe_manager: IUniverseManager
+    _exporter: ITradeDataExport | None = None
 
     _handlers: dict[str, Callable[["ProcessingManager", Instrument, str, Any], TriggerEvent | None]]
     _strategy_name: str
@@ -78,6 +80,7 @@ class ProcessingManager(IProcessingManager):
         cache: CachedMarketDataHolder,
         scheduler: BasicScheduler,
         is_simulation: bool,
+        exporter: ITradeDataExport | None = None,
     ):
         self._context = context
         self._strategy = strategy
@@ -92,6 +95,7 @@ class ProcessingManager(IProcessingManager):
         self._universe_manager = universe_manager
         self._cache = cache
         self._scheduler = scheduler
+        self._exporter = exporter
 
         self._pool = ThreadPool(2) if not self._is_simulation else None
         self._handlers = {
@@ -239,7 +243,13 @@ class ProcessingManager(IProcessingManager):
         # - check if trading is allowed for each target position
         target_positions = [t for t in target_positions if self._universe_manager.is_trading_allowed(t.instrument)]
 
+        # - log target positions
         self._logging.save_signals_targets(target_positions)
+
+        # - export target positions if exporter is available
+        if self._exporter is not None:
+            self._exporter.export_target_positions(self._time_provider.time(), target_positions, self._account)
+
         return target_positions
 
     def __process_signals_from_target_positions(
@@ -270,6 +280,10 @@ class ProcessingManager(IProcessingManager):
                     continue
                 signal.reference_price = q.mid_price()
 
+        # - export signals if exporter is available
+        if self._exporter is not None and signals:
+            self._exporter.export_signals(self._time_provider.time(), signals, self._account)
+
         return signals
 
     def _run_in_thread_pool(self, func: Callable, args=()):
@@ -414,14 +428,25 @@ class ProcessingManager(IProcessingManager):
         self._account.process_deals(instrument, deals)
         self._logging.save_deals(instrument, deals)
 
+        # - Process all deals first
         for d in deals:
             # - notify position gatherer and tracker
             self._position_gathering.on_execution_report(self._context, instrument, d)
             self._position_tracker.on_execution_report(self._context, instrument, d)
+
             logger.debug(
                 f"[<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: executed <r>{d.order_id}</r> | {d.amount} @ {d.price}"
             )
 
+        if self._exporter is not None and (q := self._market_data.quote(instrument)) is not None:
+            # - export position changes if exporter is available
+            self._exporter.export_position_changes(
+                time=self._time_provider.time(),
+                instrument=instrument,
+                price=q.mid_price(),
+                account=self._account,
+            )
+
         # - notify universe manager about position change
         self._universe_manager.on_alter_position(instrument)
 

qubx/exporters/__init__.py

@@ -0,0 +1,10 @@
+"""
+This module contains exporters for trading data.
+
+Exporters are used to export trading data to external systems.
+"""
+
+from qubx.exporters.redis_streams import RedisStreamsExporter
+from qubx.exporters.slack import SlackExporter
+
+__all__ = ["RedisStreamsExporter", "SlackExporter"] 

qubx/exporters/formatters/__init__.py

@@ -0,0 +1,11 @@
+"""
+Formatters for exporting trading data.
+
+This module provides interfaces and implementations for formatting trading data
+before it is exported to external systems.
+"""
+
+from qubx.exporters.formatters.base import DefaultFormatter, IExportFormatter
+from qubx.exporters.formatters.slack import SlackMessageFormatter
+
+__all__ = ["IExportFormatter", "DefaultFormatter", "SlackMessageFormatter"]

qubx/exporters/formatters/base.py

@@ -0,0 +1,162 @@
+"""
+Base formatter interfaces and implementations.
+
+This module provides the base formatter interface and a default implementation
+for formatting trading data before it is exported to external systems.
+"""
+
+import json
+from abc import ABC, abstractmethod
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from qubx.core.basics import Instrument, Signal, TargetPosition, dt_64
+from qubx.core.interfaces import IAccountViewer
+
+
+class IExportFormatter(ABC):
+    """
+    Interface for formatting trading data before export.
+
+    Formatters are responsible for converting trading data objects (signals, target positions, etc.)
+    into a format suitable for export to external systems.
+    """
+
+    @abstractmethod
+    def format_signal(self, time: dt_64, signal: Signal, account: IAccountViewer) -> dict[str, Any]:
+        """
+        Format a signal for export.
+
+        Args:
+            time: Timestamp when the signal was generated
+            signal: The signal to format
+            account: Account viewer to get account information like total capital, leverage, etc.
+        Returns:
+            A dictionary containing the formatted signal data
+        """
+        pass
+
+    @abstractmethod
+    def format_target_position(self, time: dt_64, target: TargetPosition, account: IAccountViewer) -> dict[str, Any]:
+        """
+        Format a target position for export.
+
+        Args:
+            time: Timestamp when the target position was generated
+            target: The target position to format
+            account: Account viewer to get account information like total capital, leverage, etc.
+
+        Returns:
+            A dictionary containing the formatted target position data
+        """
+        pass
+
+    @abstractmethod
+    def format_position_change(
+        self, time: dt_64, instrument: Instrument, price: float, account: IAccountViewer
+    ) -> dict[str, Any]:
+        """
+        Format a leverage change for export.
+
+        Args:
+            time: Timestamp when the leverage change occurred
+            instrument: The instrument for which the leverage changed
+            price: Price at which the leverage changed
+            account: Account viewer to get account information like total capital, leverage, etc.
+
+        Returns:
+            A dictionary containing the formatted leverage change data
+        """
+        pass
+
+
+class DefaultFormatter(IExportFormatter):
+    """
+    Default implementation of the IExportFormatter interface.
+
+    This formatter creates standardized JSON-serializable dictionaries for each data type.
+    """
+
+    def _format_timestamp(self, timestamp: Any) -> str:
+        """
+        Format a timestamp for export.
+
+        Args:
+            timestamp: The timestamp to format
+
+        Returns:
+            The formatted timestamp as a string
+        """
+        if timestamp is not None:
+            return pd.Timestamp(timestamp).isoformat()
+        else:
+            return ""
+
+    def format_signal(self, time: dt_64, signal: Signal, account: IAccountViewer) -> dict[str, Any]:
+        """
+        Format a signal for export.
+
+        Args:
+            time: Timestamp when the signal was generated
+            signal: The signal to format
+            account: Account viewer to get account information like total capital, leverage, etc.
+
+        Returns:
+            A dictionary containing the formatted signal data
+        """
+        return {
+            "timestamp": self._format_timestamp(time),
+            "instrument": signal.instrument.symbol,
+            "exchange": signal.instrument.exchange,
+            "direction": str(signal.signal),
+            "strength": str(abs(signal.signal)),
+            "reference_price": str(signal.reference_price) if signal.reference_price is not None else "",
+            "group": signal.group,
+            "metadata": json.dumps(signal.options) if signal.options else "",
+        }
+
+    def format_target_position(self, time: dt_64, target: TargetPosition, account: IAccountViewer) -> dict[str, Any]:
+        """
+        Format a target position for export.
+
+        Args:
+            time: Timestamp when the target position was generated
+            target: The target position to format
+            account: Account viewer to get account information like total capital, leverage, etc.
+
+        Returns:
+            A dictionary containing the formatted target position data
+        """
+        return {
+            "timestamp": self._format_timestamp(time),
+            "instrument": target.instrument.symbol,
+            "exchange": target.instrument.exchange,
+            "target_size": str(target.target_position_size),
+            "price": str(target.price) if target.price is not None else "",
+            "signal_id": str(id(target.signal)) if target.signal else "",
+        }
+
+    def format_position_change(
+        self, time: dt_64, instrument: Instrument, price: float, account: IAccountViewer
+    ) -> dict[str, Any]:
+        """
+        Format a position change for export.
+
+        Args:
+            time: Timestamp when the leverage change occurred
+            instrument: The instrument for which the leverage changed
+            price: Price at which the leverage changed
+            account: Account viewer to get account information like total capital, leverage, etc.
+
+        Returns:
+            A dictionary containing the formatted leverage change data
+        """
+        return {
+            "timestamp": self._format_timestamp(time),
+            "instrument": instrument.symbol,
+            "exchange": instrument.exchange,
+            "price": price,
+            "target_quantity": account.get_position(instrument).quantity,
+        }

qubx/exporters/formatters/incremental.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+from qubx.core.basics import Instrument, dt_64
+from qubx.core.interfaces import IAccountViewer
+from qubx.exporters.formatters.base import DefaultFormatter
+
+
+class IncrementalFormatter(DefaultFormatter):
+    """
+    Incremental formatter for exporting trading data.
+    """
+
+    def format_position_change(
+        self, time: dt_64, instrument: Instrument, price: float, account: IAccountViewer
+    ) -> dict[str, Any]:
+        return {}

qubx/exporters/formatters/slack.py

@@ -0,0 +1,183 @@
+"""
+Slack message formatter for trading data.
+
+This module provides a formatter for converting trading data into Slack message blocks
+suitable for posting to Slack channels.
+"""
+
+import json
+from typing import Any, Dict, List
+
+from qubx.core.basics import Instrument, Signal, TargetPosition, dt_64
+from qubx.core.interfaces import IAccountViewer
+from qubx.exporters.formatters.base import DefaultFormatter, IExportFormatter
+
+
+class SlackMessageFormatter(IExportFormatter):
+    """
+    Formatter for converting trading data into Slack message blocks.
+
+    This formatter creates structured Slack message blocks for signals, target positions,
+    and position changes, suitable for posting to Slack channels.
+    """
+
+    def __init__(self, strategy_emoji: str = ":chart_with_upwards_trend:", include_account_info: bool = True):
+        """
+        Initialize the Slack message formatter.
+
+        Args:
+            strategy_emoji: Emoji to use for the strategy in messages
+            include_account_info: Whether to include account information in messages
+        """
+        self._strategy_emoji = strategy_emoji
+        self._include_account_info = include_account_info
+        self._default_formatter = DefaultFormatter()  # For basic data formatting
+
+    def _format_timestamp(self, timestamp: Any) -> str:
+        """Format timestamp for display in Slack messages."""
+        return self._default_formatter._format_timestamp(timestamp)
+
+    def _create_header_block(self, title: str, timestamp: str) -> Dict[str, Any]:
+        """Create a header block for Slack messages."""
+        return {
+            "type": "header",
+            "text": {"type": "plain_text", "text": f"{self._strategy_emoji} {title} - {timestamp}", "emoji": True},
+        }
+
+    def _create_section_block(self, text: str) -> Dict[str, Any]:
+        """Create a section block for Slack messages."""
+        return {"type": "section", "text": {"type": "mrkdwn", "text": text}}
+
+    def _create_divider_block(self) -> Dict[str, Any]:
+        """Create a divider block for Slack messages."""
+        return {"type": "divider"}
+
+    def _format_account_info(self, account: IAccountViewer) -> str:
+        """Format account information for inclusion in Slack messages."""
+        if not self._include_account_info:
+            return ""
+
+        total_capital = account.get_total_capital()
+        return f"*Account Info:*\nTotal Capital: {total_capital:.2f}"
+
+    def format_signal(self, time: dt_64, signal: Signal, account: IAccountViewer) -> dict[str, Any]:
+        """
+        Format a signal as a Slack message.
+
+        Args:
+            time: Timestamp when the signal was generated
+            signal: The signal to format
+            account: Account viewer to get account information
+
+        Returns:
+            A dictionary containing the formatted Slack message blocks
+        """
+        timestamp = self._format_timestamp(time)
+        direction = "🔴 SELL" if signal.signal < 0 else "🟢 BUY" if signal.signal > 0 else "⚪ NEUTRAL"
+        strength = abs(signal.signal)
+
+        # Basic signal data
+        signal_text = (
+            f"*Signal:* {direction} (Strength: {strength:.2f})\n"
+            f"*Instrument:* {signal.instrument.symbol} ({signal.instrument.exchange})\n"
+        )
+
+        # Add reference price if available
+        if signal.reference_price is not None:
+            signal_text += f"*Reference Price:* {signal.reference_price}\n"
+
+        # Add group if available
+        if signal.group:
+            signal_text += f"*Group:* {signal.group}\n"
+
+        # Add metadata if available
+        if signal.options:
+            signal_text += f"*Metadata:* {json.dumps(signal.options)}\n"
+
+        if signal.comment:
+            signal_text += f"*Comment:* {signal.comment}\n"
+
+        # Create blocks
+        blocks = [self._create_header_block("New Signal", timestamp), self._create_section_block(signal_text)]
+
+        # Add account info if enabled
+        if self._include_account_info:
+            account_text = self._format_account_info(account)
+            if account_text:
+                blocks.append(self._create_divider_block())
+                blocks.append(self._create_section_block(account_text))
+
+        return {"blocks": blocks}
+
+    def format_target_position(self, time: dt_64, target: TargetPosition, account: IAccountViewer) -> dict[str, Any]:
+        """
+        Format a target position as a Slack message.
+
+        Args:
+            time: Timestamp when the target position was generated
+            target: The target position to format
+            account: Account viewer to get account information
+
+        Returns:
+            A dictionary containing the formatted Slack message blocks
+        """
+        timestamp = self._format_timestamp(time)
+
+        # Basic target position data
+        target_text = (
+            f"*Instrument:* {target.instrument.symbol} ({target.instrument.exchange})\n"
+            f"*Target Size:* {target.target_position_size}\n"
+        )
+
+        # Add price if available
+        if target.price is not None:
+            target_text += f"*Price:* {target.price}\n"
+
+        # Create blocks
+        blocks = [self._create_header_block("Target Position", timestamp), self._create_section_block(target_text)]
+
+        # Add account info if enabled
+        if self._include_account_info:
+            account_text = self._format_account_info(account)
+            if account_text:
+                blocks.append(self._create_divider_block())
+                blocks.append(self._create_section_block(account_text))
+
+        return {"blocks": blocks}
+
+    def format_position_change(
+        self, time: dt_64, instrument: Instrument, price: float, account: IAccountViewer
+    ) -> dict[str, Any]:
+        """
+        Format a position change as a Slack message.
+
+        Args:
+            time: Timestamp when the position change occurred
+            instrument: The instrument for which the position changed
+            price: Price at which the position changed
+            account: Account viewer to get account information
+
+        Returns:
+            A dictionary containing the formatted Slack message blocks
+        """
+        timestamp = self._format_timestamp(time)
+        position = account.get_position(instrument)
+
+        # Basic position change data
+        position_text = (
+            f"*Instrument:* {instrument.symbol} ({instrument.exchange})\n"
+            f"*Price:* {price}\n"
+            f"*Current Quantity:* {position.quantity}\n"
+        )
+
+        # Create blocks
+        blocks = [self._create_header_block("Position Change", timestamp), self._create_section_block(position_text)]
+
+        # Add account info if enabled
+        if self._include_account_info:
+            account_text = self._format_account_info(account)
+            if account_text:
+                blocks.append(self._create_divider_block())
+                blocks.append(self._create_section_block(account_text))
+
+        return {"blocks": blocks}

qubx/exporters/redis_streams.py

@@ -0,0 +1,177 @@
+"""
+Redis Streams Exporter for trading data.
+
+This module provides an implementation of ITradeDataExport that exports trading data to Redis Streams.
+"""
+
+from typing import Any, Dict, List, Optional, TypeVar, cast
+
+import redis
+from redis.typing import EncodableT, FieldT
+
+from qubx import logger
+from qubx.core.basics import Instrument, Signal, TargetPosition, dt_64
+from qubx.core.interfaces import IAccountViewer, ITradeDataExport
+from qubx.exporters.formatters import DefaultFormatter, IExportFormatter
+
+
+class RedisStreamsExporter(ITradeDataExport):
+    """
+    Exports trading data to Redis Streams.
+
+    This exporter can be configured to export signals, target positions, and leverage changes.
+    """
+
+    def __init__(
+        self,
+        redis_url: str,
+        strategy_name: str,
+        export_signals: bool = True,
+        export_targets: bool = True,
+        export_position_changes: bool = True,
+        signals_stream: Optional[str] = None,
+        targets_stream: Optional[str] = None,
+        position_changes_stream: Optional[str] = None,
+        max_stream_length: int = 1000,
+        formatter: Optional[IExportFormatter] = None,
+    ):
+        """
+        Initialize the Redis Streams Exporter.
+
+        Args:
+            redis_url: Redis connection URL (e.g., "redis://localhost:6379/0")
+            strategy_name: Name of the strategy (used in stream keys if not provided)
+            export_signals: Whether to export signals
+            export_targets: Whether to export target positions
+            export_position_changes: Whether to export position changes
+            signals_stream: Custom stream name for signals (default: "strategy:{strategy_name}:signals")
+            targets_stream: Custom stream name for target positions (default: "strategy:{strategy_name}:targets")
+            position_changes_stream: Custom stream name for position changes (default: "strategy:{strategy_name}:position_changes")
+            max_stream_length: Maximum length of each stream
+            formatter: Formatter to use for formatting data (default: DefaultFormatter)
+        """
+        self._redis = redis.from_url(redis_url)
+        self._strategy_name = strategy_name
+
+        self._export_signals = export_signals
+        self._export_targets = export_targets
+        self._export_position_changes = export_position_changes
+
+        self._signals_stream = signals_stream or f"strategy:{strategy_name}:signals"
+        self._targets_stream = targets_stream or f"strategy:{strategy_name}:targets"
+        self._position_changes_stream = position_changes_stream or f"strategy:{strategy_name}:position_changes"
+
+        self._max_stream_length = max_stream_length
+        self._formatter = formatter or DefaultFormatter()
+
+        self._instrument_to_previous_leverage = {}
+
+        logger.info(
+            f"[RedisStreamsExporter] Initialized for strategy '{strategy_name}' with "
+            f"signals: {export_signals}, targets: {export_targets}, position_changes: {export_position_changes}"
+        )
+
+    def _prepare_for_redis(self, data: Dict[str, Any]) -> Dict[FieldT, EncodableT]:
+        """
+        Prepare data for Redis by ensuring all values are strings.
+
+        Args:
+            data: Dictionary with string keys and any values
+
+        Returns:
+            Dictionary with keys and values compatible with Redis
+        """
+        # Convert all values to strings and cast the result to the type expected by Redis
+        string_dict = {k: str(v) for k, v in data.items()}
+        return cast(Dict[FieldT, EncodableT], string_dict)
+
+    def export_signals(self, time: dt_64, signals: List[Signal], account: IAccountViewer) -> None:
+        """
+        Export signals to Redis Stream.
+
+        Args:
+            time: Timestamp when the signals were generated
+            signals: List of signals to export
+            account: Account viewer to get account information like total capital, leverage, etc.
+        """
+        if not self._export_signals or not signals:
+            return
+
+        try:
+            for signal in signals:
+                # Format the signal using the formatter
+                data = self._formatter.format_signal(time, signal, account)
+
+                # Prepare data for Redis
+                redis_data = self._prepare_for_redis(data)
+
+                # Add to Redis stream
+                self._redis.xadd(self._signals_stream, redis_data, maxlen=self._max_stream_length, approximate=True)
+
+            logger.debug(f"[RedisStreamsExporter] Exported {len(signals)} signals to {self._signals_stream}")
+        except Exception as e:
+            logger.error(f"[RedisStreamsExporter] Failed to export signals: {e}")
+
+    def export_target_positions(self, time: dt_64, targets: List[TargetPosition], account: IAccountViewer) -> None:
+        """
+        Export target positions to Redis Stream.
+
+        Args:
+            time: Timestamp when the target positions were generated
+            targets: List of target positions to export
+            account: Account viewer to get account information like total capital, leverage, etc.
+        """
+        if not self._export_targets or not targets:
+            return
+
+        try:
+            for target in targets:
+                # Format the target position using the formatter
+                data = self._formatter.format_target_position(time, target, account)
+
+                # Prepare data for Redis
+                redis_data = self._prepare_for_redis(data)
+
+                # Add to Redis stream
+                self._redis.xadd(self._targets_stream, redis_data, maxlen=self._max_stream_length, approximate=True)
+
+            logger.debug(f"[RedisStreamsExporter] Exported {len(targets)} target positions to {self._targets_stream}")
+        except Exception as e:
+            logger.error(f"[RedisStreamsExporter] Failed to export target positions: {e}")
+
+    def export_position_changes(
+        self, time: dt_64, instrument: Instrument, price: float, account: IAccountViewer
+    ) -> None:
+        """
+        Export leverage changes to Redis Stream.
+
+        Args:
+            time: Timestamp when the leverage change occurred
+            instrument: The instrument for which the leverage changed
+            price: Price at which the leverage changed
+            account: Account viewer to get account information like total capital, leverage, etc.
+        """
+        if not self._export_position_changes:
+            return
+
+        previous_leverage = self._instrument_to_previous_leverage.get(instrument)
+        new_leverage = account.get_leverage(instrument)
+
+        try:
+            # Format the leverage change using the formatter
+            data = self._formatter.format_position_change(time, instrument, price, account)
+
+            # Prepare data for Redis
+            redis_data = self._prepare_for_redis(data)
+
+            # Add to Redis stream
+            self._redis.xadd(
+                self._position_changes_stream, redis_data, maxlen=self._max_stream_length, approximate=True
+            )
+
+            logger.debug(
+                f"[RedisStreamsExporter] Exported position change for {instrument}: "
+                f"{previous_leverage} -> {new_leverage} @ {price}"
+            )
+        except Exception as e:
+            logger.error(f"[RedisStreamsExporter] Failed to export position change: {e}")

qubx/exporters/slack.py

@@ -0,0 +1,174 @@
+"""
+Slack Exporter for trading data.
+
+This module provides an implementation of ITradeDataExport that exports trading data to Slack channels.
+"""
+
+from typing import Dict, List, Optional
+
+import requests
+
+from qubx import logger
+from qubx.core.basics import Instrument, Signal, TargetPosition, dt_64
+from qubx.core.interfaces import IAccountViewer, ITradeDataExport
+from qubx.exporters.formatters import IExportFormatter, SlackMessageFormatter
+
+
+class SlackExporter(ITradeDataExport):
+    """
+    Exports trading data to Slack channels.
+
+    This exporter can be configured to export signals, target positions, and position changes
+    to different Slack channels using webhook URLs.
+    """
+
+    def __init__(
+        self,
+        strategy_name: str,
+        signals_webhook_url: Optional[str] = None,
+        targets_webhook_url: Optional[str] = None,
+        position_changes_webhook_url: Optional[str] = None,
+        export_signals: bool = True,
+        export_targets: bool = True,
+        export_position_changes: bool = True,
+        formatter: Optional[IExportFormatter] = None,
+        strategy_emoji: str = ":chart_with_upwards_trend:",
+        include_account_info: bool = True,
+    ):
+        """
+        Initialize the Slack Exporter.
+
+        Args:
+            strategy_name: Name of the strategy (used in message headers)
+            signals_webhook_url: Webhook URL for signals channel
+            targets_webhook_url: Webhook URL for target positions channel
+            position_changes_webhook_url: Webhook URL for position changes channel
+            export_signals: Whether to export signals
+            export_targets: Whether to export target positions
+            export_position_changes: Whether to export position changes
+            formatter: Formatter to use for formatting data (default: SlackMessageFormatter)
+            strategy_emoji: Emoji to use for the strategy in messages
+            include_account_info: Whether to include account information in messages
+        """
+        self._strategy_name = strategy_name
+
+        self._signals_webhook_url = signals_webhook_url
+        self._targets_webhook_url = targets_webhook_url
+        self._position_changes_webhook_url = position_changes_webhook_url
+
+        self._export_signals = export_signals and signals_webhook_url is not None
+        self._export_targets = export_targets and targets_webhook_url is not None
+        self._export_position_changes = export_position_changes and position_changes_webhook_url is not None
+
+        # Use provided formatter or create a new SlackMessageFormatter
+        self._formatter = formatter or SlackMessageFormatter(
+            strategy_emoji=strategy_emoji, include_account_info=include_account_info
+        )
+
+        logger.info(
+            f"[SlackExporter] Initialized for strategy '{strategy_name}' with "
+            f"signals: {self._export_signals}, targets: {self._export_targets}, "
+            f"position_changes: {self._export_position_changes}"
+        )
+
+    def _post_to_slack(self, webhook_url: str, data: Dict) -> bool:
+        """
+        Post data to a Slack webhook URL.
+
+        Args:
+            webhook_url: The Slack webhook URL to post to
+            data: The data to post
+
+        Returns:
+            bool: True if the post was successful, False otherwise
+        """
+        try:
+            response = requests.post(webhook_url, json=data)
+            response.raise_for_status()
+            return True
+        except requests.RequestException as e:
+            logger.error(f"[SlackExporter] Failed to post to Slack: {e}")
+            return False
+
+    def export_signals(self, time: dt_64, signals: List[Signal], account: IAccountViewer) -> None:
+        """
+        Export signals to Slack.
+
+        Args:
+            time: Timestamp when the signals were generated
+            signals: List of signals to export
+            account: Account viewer to get account information
+        """
+        if not self._export_signals or not signals or not self._signals_webhook_url:
+            return
+
+        try:
+            for signal in signals:
+                # Format the signal using the formatter
+                data = self._formatter.format_signal(time, signal, account)
+
+                # Post to Slack
+                success = self._post_to_slack(self._signals_webhook_url, data)
+
+                if success:
+                    logger.debug(f"[SlackExporter] Exported signal for {signal.instrument} to Slack")
+                else:
+                    logger.warning(f"[SlackExporter] Failed to export signal for {signal.instrument} to Slack")
+        except Exception as e:
+            logger.error(f"[SlackExporter] Failed to export signals: {e}")
+
+    def export_target_positions(self, time: dt_64, targets: List[TargetPosition], account: IAccountViewer) -> None:
+        """
+        Export target positions to Slack.
+
+        Args:
+            time: Timestamp when the target positions were generated
+            targets: List of target positions to export
+            account: Account viewer to get account information
+        """
+        if not self._export_targets or not targets or not self._targets_webhook_url:
+            return
+
+        try:
+            for target in targets:
+                # Format the target position using the formatter
+                data = self._formatter.format_target_position(time, target, account)
+
+                # Post to Slack
+                success = self._post_to_slack(self._targets_webhook_url, data)
+
+                if success:
+                    logger.debug(f"[SlackExporter] Exported target position for {target.instrument} to Slack")
+                else:
+                    logger.warning(f"[SlackExporter] Failed to export target position for {target.instrument} to Slack")
+        except Exception as e:
+            logger.error(f"[SlackExporter] Failed to export target positions: {e}")
+
+    def export_position_changes(
+        self, time: dt_64, instrument: Instrument, price: float, account: IAccountViewer
+    ) -> None:
+        """
+        Export position changes to Slack.
+
+        Args:
+            time: Timestamp when the position change occurred
+            instrument: The instrument for which the position changed
+            price: Price at which the position changed
+            account: Account viewer to get account information
+        """
+        if not self._export_position_changes or not self._position_changes_webhook_url:
+            return
+
+        try:
+            # Format the position change using the formatter
+            data = self._formatter.format_position_change(time, instrument, price, account)
+
+            # Post to Slack
+            success = self._post_to_slack(self._position_changes_webhook_url, data)
+
+            if success:
+                logger.debug(f"[SlackExporter] Exported position change for {instrument} to Slack")
+            else:
+                logger.warning(f"[SlackExporter] Failed to export position change for {instrument} to Slack")
+        except Exception as e:
+            logger.error(f"[SlackExporter] Failed to export position change: {e}")

{qubx-0.6.0.dist-info → qubx-0.6.1.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: Qubx
-Version: 0.6.0
+Version: 0.6.1
 Summary: Qubx - Quantitative Trading Framework
+Home-page: https://github.com/xLydianSoftware/Qubx
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com
 Requires-Python: >=3.10,<4.0
@@ -37,6 +38,7 @@ Requires-Dist: pymongo (>=4.6.1,<5.0.0)
 Requires-Dist: python-binance (>=1.0.19,<2.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: redis (>=5.2.1,<6.0.0)
 Requires-Dist: scikit-learn (>=1.4.2,<2.0.0)
 Requires-Dist: scipy (>=1.12.0,<2.0.0)
 Requires-Dist: sortedcontainers (>=2.4.0,<3.0.0)

{qubx-0.6.0.dist-info → qubx-0.6.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-qubx/__init__.py,sha256=Nd_l2nh8OqSHK3uBNlyBBlu1x-KDM6LIJZ-SfdDojWI,8435
+qubx/__init__.py,sha256=GBvbyDpm2yCMJVmGW66Jo0giLOUsKKldDGcVA_r9Ohc,8294
 qubx/_nb_magic.py,sha256=kcYn8qNb8O223ZRPpq30_n5e__lD5GSVcd0U_jhfnbM,3019
 qubx/backtester/__init__.py,sha256=OhXhLmj2x6sp6k16wm5IPATvv-E2qRZVIcvttxqPgcg,176
 qubx/backtester/account.py,sha256=VBFiUMS3So1wVJCmQ3NtZ6Px1zMyi9hVjiq5Cn7sfm8,5838
@@ -14,7 +14,7 @@ qubx/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/cli/commands.py,sha256=K5dpcXw87ApKn0U00PaQTmHQ3Imq9qFkYYmUfccIjRY,8035
 qubx/cli/deploy.py,sha256=71mxBiwKnrG-UNtkwwJsWM38zemc_PIBRpREeww5s6k,7638
 qubx/cli/misc.py,sha256=FkNG2S15FqBv3I0NnvzQCgOuh1RZCbHiZ1VkO3gSHS0,13343
-qubx/cli/release.py,sha256=8sBiTTKG8mmUtyZ6qMOJgcQskJGTufiEZP6T8Hx9Yvg,24193
+qubx/cli/release.py,sha256=R9lZR9oWodbJG8TmNgoIuH5LXntq_c0j-LsNoRsw6RU,24508
 qubx/connectors/ccxt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/connectors/ccxt/account.py,sha256=0-NyqDVEu6vim9rBgO4L9Ek3EKHmq2A82eTKpoOSyFM,21630
 qubx/connectors/ccxt/broker.py,sha256=I91BRQBbVrZm9YGp6AkW_qHSQv-6Qf0H2Rt53Pmh4rk,4114
@@ -26,30 +26,37 @@ qubx/connectors/ccxt/utils.py,sha256=Hn1gK3BCmwbivVjAmwaBy4zQPqwZl0jWbNwdV5_E0po
 qubx/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/core/account.py,sha256=MOrllpuZLyaJ1EwsEJst0GaxcC7Z7XMT-VF7OR-1NMQ,10213
 qubx/core/basics.py,sha256=7CaER2uM73840CUNe9ej9I6BzSkwgydM-RQwVsL5LZ0,27780
-qubx/core/context.py,sha256=nOzB_FFzGwjtYo7o8lwBEnJASr1fkd9B_Cc3SCcy7Kw,15616
+qubx/core/context.py,sha256=c9x-y5VHgsbM_snibBp3-_mVD-oZQiQ5xFu-PrPcRXo,15918
 qubx/core/exceptions.py,sha256=Jidp6v8rF6bCGB4SDNPt5CMHltkd9tbVkHzOvM29KdU,477
 qubx/core/helpers.py,sha256=7nhO-CgleU6RTXpSwCdMwb0ZwLCYi5hJWnag8kfFDXo,17701
-qubx/core/interfaces.py,sha256=giiZAZpNsj5cUCEJMRv9IY1LKqTkbKS41xYksAI24uE,34369
+qubx/core/interfaces.py,sha256=DdKV6MDHDS5GTNRPBd-HTgj7yQz-OXj95_u75IPqO6w,35817
 qubx/core/loggers.py,sha256=rB56Sh3aRshrYRy2fdNEbPvB9i7757BiPumyKBC2cfs,17888
 qubx/core/lookups.py,sha256=1oIF3aowRWWNC7DyHaJ5n-v8b9jBlYyOUaA-S_RnGqU,15770
 qubx/core/metrics.py,sha256=7b9kza1Fu3aGSf4llUiNTIGT1wsRDOaProK5lGk_a5M,57877
 qubx/core/mixins/__init__.py,sha256=AMCLvfNuIb1kkQl3bhCj9jIOEl2eKcVPJeyLgrkB-rk,329
 qubx/core/mixins/market.py,sha256=vcUxGsg9Tv-2Df22dXpbFlZmeHcytFDfeP_mWxXpbzE,3264
-qubx/core/mixins/processing.py,sha256=dOERoe2TkNPihuXpb1lhawU78gCIdUukZNWThc-JeJY,18097
+qubx/core/mixins/processing.py,sha256=22k2L37PmcnMz3pqjKjpneKJcp8xFXebcp-izd1IJhQ,19125
 qubx/core/mixins/subscription.py,sha256=J_SX0CNw2bPy4bhxe0vswvDXY4LCkwXSaj_1PepKRLY,8540
 qubx/core/mixins/trading.py,sha256=CQQIp1t1LJiFph5CiHQR4k4vxTymjFqrkA0awKYn4Dw,3224
 qubx/core/mixins/universe.py,sha256=1ya2P3QZrsAVXmMXqq0t6CHGAC5iMGVD2ARUAtSfv04,10062
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=1rOZY9R-8_Ihb7sCPgRdnTekyh6PUJkidy09Cdok8qA,882248
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=TRLBTp0VKB8mBA_MUHgmtTDhVXNKN5yxjmloG1vIrN0,882248
 qubx/core/series.pxd,sha256=EqgYT41FrpVB274mDG3jpLCSqK_ykkL-d-1IH8DE1ik,3301
 qubx/core/series.pyi,sha256=0cgJjqNTWfWCC392jYqnnScAg1rzuZWC0V5aZbfOflw,3889
 qubx/core/series.pyx,sha256=4XCRdH3otXsU8EJ-g4_zLQfhqR8TVjtEq_e4oDz5mZ4,33836
-qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=t3br3IiZcSbFF40HZeTEaujgoLmEOpR4PH0Bq5E9zhs,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=pdhs2kyB6RL1_FJIAfY7JSQFVC2g05AXQau9ka5ndCk,86568
 qubx/core/utils.pyi,sha256=DAjyRVPJSxK4Em-9wui2F0yYHfP5tI5DjKavXNOnHa8,276
 qubx/core/utils.pyx,sha256=k5QHfEFvqhqWfCob89ANiJDKNG8gGbOh-O4CVoneZ8M,1696
 qubx/data/__init__.py,sha256=CTbEWfMC3eVfD4v6OdhEH4AXGNybrnJJ-mxOM-n2e_M,482
 qubx/data/helpers.py,sha256=GZIQJk5m1rbCX-_heZmJrMZeTpElPT88vGosUIWDuKI,16660
 qubx/data/readers.py,sha256=RedH9MyOzrYjS3EXNwM_y4nRKbYJtU0Gs6---RFdrBA,55528
 qubx/data/tardis.py,sha256=LzKSjCEhAupMYlB46SWUo71zSKhSwh26GnGHHxhb9MQ,3769
+qubx/exporters/__init__.py,sha256=7PjLDeDrDc34HOZyEspTvmQydRDIzuvwBlvGzOziXz0,284
+qubx/exporters/formatters/__init__.py,sha256=dSaYV0OTXyA5e2IFLxXgJZNWH4hTrG47-V__0iasZRM,393
+qubx/exporters/formatters/base.py,sha256=6pNQAwTpk56owxXJ2xh_q7Nu_t60ZXk7z0w7JoHIARE,5690
+qubx/exporters/formatters/incremental.py,sha256=tFXJSWJDjlsd5e1r9ZoB6LsLHfVPHlNBBAUFSZ14aKQ,462
+qubx/exporters/formatters/slack.py,sha256=MPjbEFh7PQufPdkg_Fwiu2tVw5zYJa977tCemoI790Y,7017
+qubx/exporters/redis_streams.py,sha256=kbxCWtTEfTL0qqL2V490OKCjfnVVY4AUM_4jxpPzizI,7364
+qubx/exporters/slack.py,sha256=Ang3rlyhzAolzzgSPvnBm7ZHsv3BcnRfBFGzyAYWtr8,7147
 qubx/gathering/simplest.py,sha256=2BXyzj0wHohVYT1E4Rqwdf9K_gZPoZ_eW9MSe0uliBo,3959
 qubx/math/__init__.py,sha256=ltHSQj40sCBm3owcvtoZp34h6ws7pZCFcSZgUkTsUCY,114
 qubx/math/stats.py,sha256=dLfomw5uBYolurxNPKxcGoL27pTEqiTnjI5cZ_-9-gU,4021
@@ -64,7 +71,7 @@ qubx/resources/instruments/symbols-bitfinex.json,sha256=CpzoVgWzGZRN6RpUNhtJVxa3
 qubx/resources/instruments/symbols-kraken.f.json,sha256=lwNqml3H7lNUl1h3siySSyE1MRcGfqfhb6BcxLsiKr0,212258
 qubx/resources/instruments/symbols-kraken.json,sha256=RjUTvkQuuu7V1HfSQREvnA4qqkdkB3-rzykDaQds2rQ,456544
 qubx/ta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=rKQBW2in5_A1G0AwgkpS0asNdNPXoAef-MtyUAPftRo,654440
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=6dtnzC2d4aaGy1A612whYjNR_KpY7ABqYFhSToiZrcc,654440
 qubx/ta/indicators.pxd,sha256=eCJ9paOxtxbDFx4U5CUhcgB1jjCQAfVqMF2FnbJ03Lo,4222
 qubx/ta/indicators.pyi,sha256=NJlvN_774UV1U3_lvaYYbCEikLR8sOUo0TdcUGR5GBM,1940
 qubx/ta/indicators.pyx,sha256=FVkv5ld04TpZMT3a_kR1MU3IUuWfijzjJnh_lG78JxM,26029
@@ -98,7 +105,7 @@ qubx/utils/runner/configs.py,sha256=nQXU1oqtSSGpGHw4cqk1dVpcojibj7bzjWZbDAHRxNc,
 qubx/utils/runner/runner.py,sha256=Q8kXM0KTr2bvUuMu86eKaNmeQsyD4_LQKpYNaQra5yk,17923
 qubx/utils/time.py,sha256=1Cvh077Uqf-XjcE5nWp_T9JzFVT6i39kU7Qz-ssHKIo,9630
 qubx/utils/version.py,sha256=3MwAel409o-Fj_1iM8m46hswldOozvTywOpEMq0BZSo,5311
-qubx-0.6.0.dist-info/METADATA,sha256=kgM_2dCdmfYwHpelUMNnFkxmhQVFfszgEO809fHcrCA,3979
-qubx-0.6.0.dist-info/WHEEL,sha256=h1DdjcD2ZFnKGsDLjEycQhNNPJ5l-R8qdFdDSXHrAGY,110
-qubx-0.6.0.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.0.dist-info/RECORD,,
+qubx-0.6.1.dist-info/METADATA,sha256=yedqZAehlC77cCdlEnc1jtAF8dbx_ZO0EWIjQmCsDOo,4068
+qubx-0.6.1.dist-info/WHEEL,sha256=x1HiyTP_r-PIOu3STHzjukjf5kVLXzgVftSXf5bl8AU,110
+qubx-0.6.1.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.1.dist-info/RECORD,,

{qubx-0.6.0.dist-info → qubx-0.6.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.1
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: false
 Tag: cp312-cp312-manylinux_2_39_x86_64