Qubx 0.6.0__tar.gz → 0.6.1__tar.gz

{qubx-0.6.0 → qubx-0.6.1}/PKG-INFO

@@ -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 → qubx-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.0"
+version = "0.6.1"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"
@@ -24,50 +24,51 @@ format = "wheel"
 [tool.ruff]
 line-length = 120
 
+[tool.poetry.build]
+script = "build.py"
+generate-setup-file = false
+
+[tool.poetry.scripts]
+qubx = "qubx.cli.commands:main"
+
 [tool.poetry.dependencies]
 python = ">=3.10,<4.0"
 numpy = "^1.26.3"
+pandas = "^2.2.2"
+pyarrow = "^15.0.0"
+scipy = "^1.12.0"
+scikit-learn = "^1.4.2"
+statsmodels = "^0.14.2"
+numba = "^0.59.1"
+sortedcontainers = "^2.4.0"
 ntplib = "^0.4.0"
+python-binance = "^1.0.19"
+ccxt = "^4.2.68"
+pymongo = "^4.6.1"
+redis = "^5.2.1"
+psycopg = "^3.1.18"
+psycopg-binary = "^3.1.19"
+psycopg-pool = "^3.2.2"
+matplotlib = "^3.8.4"
+plotly = "^5.22.0"
+dash = "^2.18.2"
+dash-bootstrap-components = "^1.6.0"
 loguru = "^0.7.2"
 tqdm = "*"
 importlib-metadata = "*"
 stackprinter = "^0.2.10"
-pymongo = "^4.6.1"
 pydantic = "^2.9.2"
 python-dotenv = "^1.0.0"
-python-binance = "^1.0.19"
-pyarrow = "^15.0.0"
-scipy = "^1.12.0"
 cython = "3.0.8"
-ccxt = "^4.2.68"
 croniter = "^2.0.5"
-psycopg = "^3.1.18"
-pandas = "^2.2.2"
-statsmodels = "^0.14.2"
-matplotlib = "^3.8.4"
-numba = "^0.59.1"
-scikit-learn = "^1.4.2"
-plotly = "^5.22.0"
-psycopg-binary = "^3.1.19"
-psycopg-pool = "^3.2.2"
-sortedcontainers = "^2.4.0"
 msgspec = "^0.18.6"
 pyyaml = "^6.0.2"
-dash = "^2.18.2"
-dash-bootstrap-components = "^1.6.0"
 tabulate = "^0.9.0"
-jupyter-console = "^6.6.3"
 toml = "^0.10.2"
 gitpython = "^3.1.44"
-ipywidgets = "^8.1.5"
 jupyter = "^1.1.1"
-
-[tool.poetry.build]
-script = "build.py"
-generate-setup-file = false
-
-[tool.poetry.scripts]
-qubx = "qubx.cli.commands:main"
+jupyter-console = "^6.6.3"
+ipywidgets = "^8.1.5"
 
 [tool.ruff.lint]
 extend-select = [ "I",]
@@ -77,7 +78,7 @@ ignore = [ "E731", "E722", "E741",]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
 pythonpath = [ "src",]
-markers = [ "integration: mark a test as an integration test",]
+markers = [ "integration: mark test as requiring external services like Redis", "e2e: mark test as requiring external exchange connections and API credentials",]
 addopts = "--disable-warnings"
 filterwarnings = [ "ignore:.*Jupyter is migrating.*:DeprecationWarning",]
 

{qubx-0.6.0 → qubx-0.6.1}/src/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-0.6.0 → qubx-0.6.1}/src/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-0.6.0 → qubx-0.6.1}/src/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-0.6.0 → qubx-0.6.1}/src/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-0.6.0 → qubx-0.6.1}/src/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-0.6.1/src/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-0.6.1/src/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-0.6.1/src/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-0.6.1/src/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 {}