Qubx 0.6.37__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.38__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/runner.py

@@ -20,8 +20,9 @@ from qubx.core.interfaces import (
     ITimeProvider,
     StrategyState,
 )
-from qubx.core.loggers import InMemoryLogsWriter, StrategyLogging
+from qubx.core.loggers import StrategyLogging
 from qubx.core.lookups import lookup
+from qubx.loggers.inmemory import InMemoryLogsWriter
 from qubx.pandaz.utils import _frame_to_str
 
 from .account import SimulatedAccountProcessor

qubx/core/loggers.py

@@ -1,10 +1,6 @@
-import csv
-import os
-from multiprocessing.pool import ThreadPool
 from typing import Any, Dict, List, Tuple
 
 import numpy as np
-import pandas as pd
 
 from qubx import logger
 from qubx.core.basics import (
@@ -14,11 +10,11 @@ from qubx.core.basics import (
     Position,
     TargetPosition,
 )
-from qubx.core.metrics import split_cumulative_pnl
+
 from qubx.core.series import time_as_nsec
 from qubx.core.utils import recognize_timeframe
-from qubx.pandaz.utils import scols
-from qubx.utils.misc import Stopwatch, makedirs
+
+from qubx.utils.misc import Stopwatch
 from qubx.utils.time import convert_tf_str_td64, floor_t64
 
 _SW = Stopwatch()
@@ -48,159 +44,6 @@ class LogsWriter:
         pass
 
 
-class InMemoryLogsWriter(LogsWriter):
-    _portfolio: List
-    _execs: List
-    _signals: List
-
-    def __init__(self, account_id: str, strategy_id: str, run_id: str) -> None:
-        super().__init__(account_id, strategy_id, run_id)
-        self._portfolio = []
-        self._execs = []
-        self._signals = []
-
-    def write_data(self, log_type: str, data: List[Dict[str, Any]]):
-        if len(data) > 0:
-            if log_type == "portfolio":
-                self._portfolio.extend(data)
-            elif log_type == "executions":
-                self._execs.extend(data)
-            elif log_type == "signals":
-                self._signals.extend(data)
-
-    def get_portfolio(self, as_plain_dataframe=True) -> pd.DataFrame:
-        pfl = pd.DataFrame.from_records(self._portfolio, index="timestamp")
-        pfl.index = pd.DatetimeIndex(pfl.index)
-        if as_plain_dataframe:
-            # - convert to Qube presentation (TODO: temporary)
-            pis = []
-            for s in set(pfl["symbol"]):
-                pi = pfl[pfl["symbol"] == s]
-                pi = pi.drop(columns=["symbol", "realized_pnl_quoted", "current_price", "exchange_time"])
-                pi = pi.rename(
-                    {
-                        "pnl_quoted": "PnL",
-                        "quantity": "Pos",
-                        "avg_position_price": "Price",
-                        "market_value_quoted": "Value",
-                        "commissions_quoted": "Commissions",
-                    },
-                    axis=1,
-                )
-                # We want to convert the value to just price * quantity
-                # in reality value of perps is just the unrealized pnl but
-                # it's not important after simulation for metric calculations
-                pi["Value"] = pi["Pos"] * pi["Price"] + pi["Value"]
-                pis.append(pi.rename(lambda x: s + "_" + x, axis=1))
-            return split_cumulative_pnl(scols(*pis))
-        return pfl
-
-    def get_executions(self) -> pd.DataFrame:
-        p = pd.DataFrame()
-        if self._execs:
-            p = pd.DataFrame.from_records(self._execs, index="timestamp")
-            p.index = pd.DatetimeIndex(p.index)
-        return p
-
-    def get_signals(self) -> pd.DataFrame:
-        p = pd.DataFrame()
-        if self._signals:
-            p = pd.DataFrame.from_records(self._signals, index="timestamp")
-            p.index = pd.DatetimeIndex(p.index)
-        return p
-
-
-class CsvFileLogsWriter(LogsWriter):
-    """
-    Simple CSV strategy log data writer. It does data writing in separate thread.
-    """
-
-    def __init__(self, account_id: str, strategy_id: str, run_id: str, log_folder="logs") -> None:
-        super().__init__(account_id, strategy_id, run_id)
-
-        path = makedirs(log_folder)
-        # - it rewrites positions every time
-        self._pos_file_path = f"{path}/{self.strategy_id}_{self.account_id}_positions.csv"
-        self._balance_file_path = f"{path}/{self.strategy_id}_{self.account_id}_balance.csv"
-
-        _pfl_path = f"{path}/{strategy_id}_{account_id}_portfolio.csv"
-        _exe_path = f"{path}/{strategy_id}_{account_id}_executions.csv"
-        _sig_path = f"{path}/{strategy_id}_{account_id}_signals.csv"
-        self._hdr_pfl = not os.path.exists(_pfl_path)
-        self._hdr_exe = not os.path.exists(_exe_path)
-        self._hdr_sig = not os.path.exists(_sig_path)
-
-        self._pfl_file_ = open(_pfl_path, "+a", newline="")
-        self._execs_file_ = open(_exe_path, "+a", newline="")
-        self._sig_file_ = open(_sig_path, "+a", newline="")
-        self._pfl_writer = csv.writer(self._pfl_file_)
-        self._exe_writer = csv.writer(self._execs_file_)
-        self._sig_writer = csv.writer(self._sig_file_)
-        self.pool = ThreadPool(3)
-
-    @staticmethod
-    def _header(d: dict) -> List[str]:
-        return list(d.keys()) + ["run_id"]
-
-    def _values(self, data: List[Dict[str, Any]]) -> List[List[str]]:
-        # - attach run_id (last column)
-        return [list((d | {"run_id": self.run_id}).values()) for d in data]
-
-    def _do_write(self, log_type, data):
-        match log_type:
-            case "positions":
-                with open(self._pos_file_path, "w", newline="") as f:
-                    w = csv.writer(f)
-                    w.writerow(self._header(data[0]))
-                    w.writerows(self._values(data))
-
-            case "portfolio":
-                if self._hdr_pfl:
-                    self._pfl_writer.writerow(self._header(data[0]))
-                    self._hdr_pfl = False
-                self._pfl_writer.writerows(self._values(data))
-                self._pfl_file_.flush()
-
-            case "executions":
-                if self._hdr_exe:
-                    self._exe_writer.writerow(self._header(data[0]))
-                    self._hdr_exe = False
-                self._exe_writer.writerows(self._values(data))
-                self._execs_file_.flush()
-
-            case "signals":
-                if self._hdr_sig:
-                    self._sig_writer.writerow(self._header(data[0]))
-                    self._hdr_sig = False
-                self._sig_writer.writerows(self._values(data))
-                self._sig_file_.flush()
-
-            case "balance":
-                with open(self._balance_file_path, "w", newline="") as f:
-                    w = csv.writer(f)
-                    w.writerow(self._header(data[0]))
-                    w.writerows(self._values(data))
-
-    def write_data(self, log_type: str, data: List[Dict[str, Any]]):
-        if len(data) > 0:
-            self.pool.apply_async(self._do_write, (log_type, data))
-
-    def flush_data(self):
-        try:
-            self._pfl_file_.flush()
-            self._execs_file_.flush()
-            self._sig_file_.flush()
-        except Exception as e:
-            logger.warning(f"Error flushing log writer: {str(e)}")
-
-    def close(self):
-        self._pfl_file_.close()
-        self._execs_file_.close()
-        self._sig_file_.close()
-        self.pool.close()
-        self.pool.join()
-
-
 class _BaseIntervalDumper:
     """
     Basic functionality for all interval based dumpers

qubx/loggers/__init__.py

@@ -0,0 +1,17 @@
+"""
+Loggers module for qubx.
+
+This module provides implementations for logs writing, like csv writer or mongodb writer.
+"""
+
+from qubx.loggers.csv import CsvFileLogsWriter
+from qubx.loggers.inmemory import InMemoryLogsWriter
+from qubx.loggers.mongo import MongoDBLogsWriter
+from qubx.loggers.factory import create_logs_writer
+
+__all__ = [
+    "CsvFileLogsWriter",
+    "InMemoryLogsWriter",
+    "MongoDBLogsWriter",
+    "create_logs_writer",
+]

qubx/loggers/csv.py

@@ -0,0 +1,100 @@
+import csv
+import os
+
+from typing import Any, Dict, List
+from multiprocessing.pool import ThreadPool
+
+from qubx import logger
+from qubx.core.loggers import LogsWriter
+from qubx.utils.misc import  makedirs
+
+class CsvFileLogsWriter(LogsWriter):
+    """
+    Simple CSV strategy log data writer. It does data writing in separate thread.
+    """
+
+    def __init__(self, account_id: str, strategy_id: str, run_id: str, log_folder="logs") -> None:
+        super().__init__(account_id, strategy_id, run_id)
+
+        path = makedirs(log_folder)
+        # - it rewrites positions every time
+        self._pos_file_path = f"{path}/{self.strategy_id}_{self.account_id}_positions.csv"
+        self._balance_file_path = f"{path}/{self.strategy_id}_{self.account_id}_balance.csv"
+
+        _pfl_path = f"{path}/{strategy_id}_{account_id}_portfolio.csv"
+        _exe_path = f"{path}/{strategy_id}_{account_id}_executions.csv"
+        _sig_path = f"{path}/{strategy_id}_{account_id}_signals.csv"
+        self._hdr_pfl = not os.path.exists(_pfl_path)
+        self._hdr_exe = not os.path.exists(_exe_path)
+        self._hdr_sig = not os.path.exists(_sig_path)
+
+        self._pfl_file_ = open(_pfl_path, "+a", newline="")
+        self._execs_file_ = open(_exe_path, "+a", newline="")
+        self._sig_file_ = open(_sig_path, "+a", newline="")
+        self._pfl_writer = csv.writer(self._pfl_file_)
+        self._exe_writer = csv.writer(self._execs_file_)
+        self._sig_writer = csv.writer(self._sig_file_)
+        self.pool = ThreadPool(3)
+
+    @staticmethod
+    def _header(d: dict) -> List[str]:
+        return list(d.keys()) + ["run_id"]
+
+    def _values(self, data: List[Dict[str, Any]]) -> List[List[str]]:
+        # - attach run_id (last column)
+        return [list((d | {"run_id": self.run_id}).values()) for d in data]
+
+    def _do_write(self, log_type, data):
+        match log_type:
+            case "positions":
+                with open(self._pos_file_path, "w", newline="") as f:
+                    w = csv.writer(f)
+                    w.writerow(self._header(data[0]))
+                    w.writerows(self._values(data))
+
+            case "portfolio":
+                if self._hdr_pfl:
+                    self._pfl_writer.writerow(self._header(data[0]))
+                    self._hdr_pfl = False
+                self._pfl_writer.writerows(self._values(data))
+                self._pfl_file_.flush()
+
+            case "executions":
+                if self._hdr_exe:
+                    self._exe_writer.writerow(self._header(data[0]))
+                    self._hdr_exe = False
+                self._exe_writer.writerows(self._values(data))
+                self._execs_file_.flush()
+
+            case "signals":
+                if self._hdr_sig:
+                    self._sig_writer.writerow(self._header(data[0]))
+                    self._hdr_sig = False
+                self._sig_writer.writerows(self._values(data))
+                self._sig_file_.flush()
+
+            case "balance":
+                with open(self._balance_file_path, "w", newline="") as f:
+                    w = csv.writer(f)
+                    w.writerow(self._header(data[0]))
+                    w.writerows(self._values(data))
+
+    def write_data(self, log_type: str, data: List[Dict[str, Any]]):
+        if len(data) > 0:
+            self.pool.apply_async(self._do_write, (log_type, data))
+
+    def flush_data(self):
+        try:
+            self._pfl_file_.flush()
+            self._execs_file_.flush()
+            self._sig_file_.flush()
+        except Exception as e:
+            logger.warning(f"Error flushing log writer: {str(e)}")
+
+    def close(self):
+        self._pfl_file_.close()
+        self._execs_file_.close()
+        self._sig_file_.close()
+        self.pool.close()
+        self.pool.join()
+

qubx/loggers/factory.py

@@ -0,0 +1,55 @@
+import inspect
+
+from typing import Type
+
+from qubx.core.loggers import LogsWriter
+from qubx.loggers.csv import CsvFileLogsWriter
+from qubx.loggers.mongo import MongoDBLogsWriter
+from qubx.loggers.inmemory import InMemoryLogsWriter
+
+# Registry of logs writer types
+LOGS_WRITER_REGISTRY: dict[str, Type[LogsWriter]] = {
+    "CsvFileLogsWriter": CsvFileLogsWriter,
+    "MongoDBLogsWriter": MongoDBLogsWriter,
+    "InMemoryLogsWriter": InMemoryLogsWriter
+}
+
+def create_logs_writer(log_writer_type: str, parameters: dict | None = None) -> LogsWriter:
+    """
+    Create a logs writer based on configuration.
+
+    Args:
+        log_wirter_type: The type of logs writer to create.
+        parameters: Parameters to pass to the logs writer constructor.
+
+    Returns:
+        An instance of the specified logs writer.
+
+    Raises:
+        ValueError: If the specified logs writer type is not registered.
+    """
+    if log_writer_type not in LOGS_WRITER_REGISTRY:
+        raise ValueError(
+            f"Unknown logs writer type: {log_writer_type}. "
+            f"Available types: {', '.join(LOGS_WRITER_REGISTRY.keys())}"
+        )
+
+    logs_writer_class = LOGS_WRITER_REGISTRY[log_writer_type]
+    params = parameters.copy() if parameters else {}
+
+    sig = inspect.signature(logs_writer_class)
+    accepted_params = set(sig.parameters.keys())
+    filtered_params = {k: v for k, v in params.items() if k in accepted_params}
+
+    return logs_writer_class(**filtered_params)
+
+
+def register_logs_writer(log_writer_type: str, logs_witer_class: Type[LogsWriter]) -> None:
+    """
+    Register a new logs writer type.
+
+    Args:
+        log_writer_type: The name of the logs writer type.
+        logs_witer_class: The logs writer class to register.
+    """
+    LOGS_WRITER_REGISTRY[log_writer_type] = logs_witer_class

qubx/loggers/inmemory.py

@@ -0,0 +1,68 @@
+import pandas as pd
+
+from typing import Any, Dict, List
+
+from qubx.core.loggers import LogsWriter
+from qubx.core.metrics import split_cumulative_pnl
+from qubx.pandaz.utils import scols
+
+class InMemoryLogsWriter(LogsWriter):
+    _portfolio: List
+    _execs: List
+    _signals: List
+
+    def __init__(self, account_id: str, strategy_id: str, run_id: str) -> None:
+        super().__init__(account_id, strategy_id, run_id)
+        self._portfolio = []
+        self._execs = []
+        self._signals = []
+
+    def write_data(self, log_type: str, data: List[Dict[str, Any]]):
+        if len(data) > 0:
+            if log_type == "portfolio":
+                self._portfolio.extend(data)
+            elif log_type == "executions":
+                self._execs.extend(data)
+            elif log_type == "signals":
+                self._signals.extend(data)
+
+    def get_portfolio(self, as_plain_dataframe=True) -> pd.DataFrame:
+        pfl = pd.DataFrame.from_records(self._portfolio, index="timestamp")
+        pfl.index = pd.DatetimeIndex(pfl.index)
+        if as_plain_dataframe:
+            # - convert to Qube presentation (TODO: temporary)
+            pis = []
+            for s in set(pfl["symbol"]):
+                pi = pfl[pfl["symbol"] == s]
+                pi = pi.drop(columns=["symbol", "realized_pnl_quoted", "current_price", "exchange_time"])
+                pi = pi.rename(
+                    {
+                        "pnl_quoted": "PnL",
+                        "quantity": "Pos",
+                        "avg_position_price": "Price",
+                        "market_value_quoted": "Value",
+                        "commissions_quoted": "Commissions",
+                    },
+                    axis=1,
+                )
+                # We want to convert the value to just price * quantity
+                # in reality value of perps is just the unrealized pnl but
+                # it's not important after simulation for metric calculations
+                pi["Value"] = pi["Pos"] * pi["Price"] + pi["Value"]
+                pis.append(pi.rename(lambda x: s + "_" + x, axis=1))
+            return split_cumulative_pnl(scols(*pis))
+        return pfl
+
+    def get_executions(self) -> pd.DataFrame:
+        p = pd.DataFrame()
+        if self._execs:
+            p = pd.DataFrame.from_records(self._execs, index="timestamp")
+            p.index = pd.DatetimeIndex(p.index)
+        return p
+
+    def get_signals(self) -> pd.DataFrame:
+        p = pd.DataFrame()
+        if self._signals:
+            p = pd.DataFrame.from_records(self._signals, index="timestamp")
+            p.index = pd.DatetimeIndex(p.index)
+        return p

qubx/loggers/mongo.py

@@ -0,0 +1,80 @@
+from datetime import datetime
+from multiprocessing.pool import ThreadPool
+from pymongo import MongoClient
+from typing import Any, Dict, List
+
+from qubx.core.loggers import LogsWriter
+
+
+class MongoDBLogsWriter(LogsWriter):
+    """
+    MongoDB implementation of LogsWriter interface.
+    Writes log data to a single MongoDB collection asynchronously.
+    Supports TTL expiration via index on 'timestamp' field.
+    """
+
+    def __init__(
+        self,
+        account_id: str,
+        strategy_id: str,
+        run_id: str,
+        mongo_uri: str = "mongodb://localhost:27017/",
+        db_name: str = "default_logs_db",
+        collection_name_prefix: str = "qubx_logs",
+        pool_size: int = 3,
+        ttl_seconds: int = 86400,
+    ) -> None:
+        super().__init__(account_id, strategy_id, run_id)
+        self.client = MongoClient(mongo_uri)
+        self.db = self.client[db_name]
+        self.pool = ThreadPool(pool_size)
+        self.collection_name_prefix = collection_name_prefix
+
+        # Ensure TTL index exists on the 'timestamp' field
+        self.db[f"{collection_name_prefix}_positions"].create_index(
+            "timestamp", expireAfterSeconds=ttl_seconds
+        )
+        self.db[f"{collection_name_prefix}_portfolio"].create_index(
+            "timestamp", expireAfterSeconds=ttl_seconds
+        )
+        self.db[f"{collection_name_prefix}_executions"].create_index(
+            "timestamp", expireAfterSeconds=ttl_seconds
+        )
+        self.db[f"{collection_name_prefix}_signals"].create_index(
+            "timestamp", expireAfterSeconds=ttl_seconds
+        )
+        self.db[f"{collection_name_prefix}_balance"].create_index(
+            "timestamp", expireAfterSeconds=ttl_seconds
+        )
+    
+    def _attach_metadata(
+        self, data: List[Dict[str, Any]], log_type: str
+    ) -> List[Dict[str, Any]]:
+        now = datetime.utcnow()
+        return [
+            {
+                **d,
+                "run_id": self.run_id,
+                "account_id": self.account_id,
+                "strategy_name": self.strategy_id,
+                "log_type": log_type,
+                "timestamp": now,
+            }
+            for d in data
+        ]
+    
+    def _do_write(self, log_type: str, data: List[Dict[str, Any]]):
+        docs = self._attach_metadata(data, log_type)
+        self.db[f"{self.collection_name_prefix}_{log_type}"].insert_many(docs)
+
+    def write_data(self, log_type: str, data: List[Dict[str, Any]]):
+        if len(data) > 0:
+            self.pool.apply_async(self._do_write, (log_type, data,))
+    
+    def flush_data(self):
+        pass
+    
+    def close(self):
+        self.pool.close()
+        self.pool.join()
+        self.client.close()

qubx/restorers/balance.py

@@ -7,6 +7,7 @@ from various sources.
 
 import os
 from pathlib import Path
+from pymongo import MongoClient
 
 import pandas as pd
 
@@ -118,3 +119,78 @@ class CsvBalanceRestorer(IBalanceRestorer):
             balances[currency] = balance
 
         return balances
+
+
+class MongoDBBalanceRestorer(IBalanceRestorer):
+    """
+    Balance restorer that reads account balances from a MongoDB collection.
+
+    This restorer queries the most recent balance entries stored using MongoDBLogsWriter.
+    It restores data only from the most recent run_id for the given bot_id.
+    """
+
+    def __init__(
+        self,
+        strategy_name: str,
+        mongo_client: MongoClient,
+        db_name: str = "default_logs_db",
+        collection_name: str = "qubx_logs",
+    ):
+        self.mongo_client = mongo_client
+        self.db_name = db_name
+        self.collection_name = collection_name
+        self.strategy_name = strategy_name
+
+        self.collection = self.mongo_client[db_name][collection_name]
+
+    def restore_balances(self) -> dict[str, AssetBalance]:
+        """
+        Restore account balances from the most recent run.
+
+        Returns:
+            A dictionary mapping currency codes to AssetBalance objects.
+            Example: {'USDT': AssetBalance(total=100000.0, locked=0.0)}
+        """
+        try:
+            match_query = {
+                "log_type": "balance",
+                "strategy_name": self.strategy_name,
+            }
+
+            latest_run_doc = (
+                self.collection.find(match_query, {"run_id": 1, "timestamp": 1})
+                .sort("timestamp", -1)
+                .limit(1)
+            )
+
+            latest_run = next(latest_run_doc, None)
+            if not latest_run:
+                logger.warning("No balance logs found for given filters.")
+                return {}
+
+            latest_run_id = latest_run["run_id"]
+
+            logger.info(f"Restoring balances from MongoDB for run_id: {latest_run_id}")
+
+            query = {**match_query, "run_id": latest_run_id}
+            logs = self.collection.find(query).sort("timestamp", 1)
+
+            balances = {}
+
+            for log in logs:
+                currency = log.get("currency")
+                if currency:
+                    total = log.get("total", 0.0)
+                    locked = log.get("locked", 0.0)
+
+                    balance = AssetBalance(
+                        total=total,
+                        locked=locked,
+                    )
+                    balance.free = total - locked
+                    balances[currency] = balance
+
+            return balances
+        except Exception as e:
+            logger.error(f"Error restoring balances from MongoDB: {e}")
+            return {}

qubx/restorers/factory.py

@@ -8,33 +8,37 @@ based on configuration.
 from typing import Type
 
 from qubx.core.lookups import GlobalLookup
-from qubx.restorers.balance import CsvBalanceRestorer
+from qubx.restorers.balance import CsvBalanceRestorer, MongoDBBalanceRestorer
 from qubx.restorers.interfaces import IBalanceRestorer, IPositionRestorer, ISignalRestorer, IStateRestorer
-from qubx.restorers.position import CsvPositionRestorer
-from qubx.restorers.signal import CsvSignalRestorer
-from qubx.restorers.state import CsvStateRestorer
+from qubx.restorers.position import CsvPositionRestorer, MongoDBPositionRestorer
+from qubx.restorers.signal import CsvSignalRestorer, MongoDBSignalRestorer
+from qubx.restorers.state import CsvStateRestorer, MongoDBStateRestorer
 
 # Registry of position restorer types
 POSITION_RESTORER_REGISTRY: dict[str, Type[IPositionRestorer]] = {
     "CsvPositionRestorer": CsvPositionRestorer,
+    "MongoDBPositionRestorer": MongoDBPositionRestorer,
 }
 
 
 # Registry of signal restorer types
 SIGNAL_RESTORER_REGISTRY: dict[str, Type[ISignalRestorer]] = {
     "CsvSignalRestorer": CsvSignalRestorer,
+    "MongoDBSignalRestorer": MongoDBSignalRestorer,
 }
 
 
 # Registry of balance restorer types
 BALANCE_RESTORER_REGISTRY: dict[str, Type[IBalanceRestorer]] = {
     "CsvBalanceRestorer": CsvBalanceRestorer,
+    "MongoDBBalanceRestorer": MongoDBBalanceRestorer,
 }
 
 
 # Registry of state restorer types
 STATE_RESTORER_REGISTRY: dict[str, Type[IStateRestorer]] = {
     "CsvStateRestorer": CsvStateRestorer,
+    "MongoDBStateRestorer": MongoDBStateRestorer,
 }
 
 

qubx/restorers/position.py

@@ -7,6 +7,7 @@ for restoring positions from various sources.
 
 import os
 from pathlib import Path
+from pymongo import MongoClient
 
 import pandas as pd
 
@@ -135,3 +136,97 @@ class CsvPositionRestorer(IPositionRestorer):
             positions[instrument] = position
 
         return positions
+
+
+class MongoDBPositionRestorer(IPositionRestorer):
+    """
+    Position restorer that reads positions from a MongoDB collection.
+
+    This restorer queries the most recent position entries stored using MongoDBLogsWriter,
+    and restores only from the latest run_id for the provided identifiers.
+    """
+
+    def __init__(
+        self,
+        strategy_name: str,
+        mongo_client: MongoClient,
+        db_name: str = "default_logs_db",
+        collection_name: str = "qubx_logs",
+    ):
+        self.mongo_client = mongo_client
+        self.db_name = db_name
+        self.collection_name = collection_name
+        self.strategy_name = strategy_name
+
+        self.collection = self.mongo_client[db_name][collection_name]
+
+    def restore_positions(self) -> dict[Instrument, Position]:
+        """
+        Restore the latest positions grouped by instrument from the most recent run.
+
+        Returns:
+            A dictionary mapping instruments to positions.
+        """
+        try:
+            match_query = {
+                "log_type": "positions",
+                "strategy_name": self.strategy_name,
+            }
+
+            latest_run_doc = (
+                self.collection.find(match_query, {"run_id": 1, "timestamp": 1})
+                .sort("timestamp", -1)
+                .limit(1)
+            )
+
+            latest_run = next(latest_run_doc, None)
+            if not latest_run:
+                logger.warning("No position logs found for given filters.")
+                return {}
+
+            latest_run_id = latest_run["run_id"]
+
+            logger.info(f"Restoring positions from MongoDB for run_id: {latest_run_id}")
+
+            query = {**match_query, "run_id": latest_run_id}
+            logs = self.collection.find(query).sort("timestamp", 1)
+
+            positions = {}
+            seen_keys = set()
+
+            for log in logs:
+                key = (log.get("symbol"), log.get("exchange"), log.get("market_type"))
+                if None in key or key in seen_keys:
+                    continue
+                seen_keys.add(key)
+
+                symbol = log["symbol"]
+                exchange = log["exchange"]
+
+                instrument = lookup.find_symbol(exchange, symbol)
+                if instrument is None:
+                    logger.warning(f"Instrument not found for {symbol} on {exchange}")
+                    continue
+
+                quantity = log.get("quantity") or log.get("size", 0.0)
+                avg_price = log.get("avg_position_price") or log.get("avg_price", 0.0)
+                r_pnl = log.get("realized_pnl_quoted") or log.get("realized_pnl", 0.0)
+                current_price = log.get("current_price")
+
+                position = Position(
+                    instrument=instrument,
+                    quantity=quantity,
+                    pos_average_price=avg_price,
+                    r_pnl=r_pnl,
+                )
+
+                if current_price is not None:
+                    timestamp = recognize_time(log.get("timestamp"))
+                    position.update_market_price(timestamp, current_price, 1.0)
+
+                positions[instrument] = position
+
+            return positions
+        except Exception as e:
+            logger.error(f"Error restoring positions from MongoDB: {e}")
+            return {}

qubx/restorers/signal.py

@@ -8,6 +8,7 @@ for restoring signals from various sources.
 import os
 from datetime import datetime, timedelta
 from pathlib import Path
+from pymongo import MongoClient
 
 import pandas as pd
 
@@ -174,3 +175,117 @@ class CsvSignalRestorer(ISignalRestorer):
             targets_by_instrument[instrument] = target_positions
 
         return targets_by_instrument
+
+
+
+class MongoDBSignalRestorer(ISignalRestorer):
+    """
+    Signal restorer that reads historical signals from MongoDB.
+
+    This restorer reads signals written by the MongoDBLogsWriter
+    for the most recent run_id associated with a given bot.
+    """
+
+    def __init__(
+        self,
+        strategy_name: str,
+        mongo_client: MongoClient,
+        db_name: str = "default_logs_db",
+        collection_name: str = "qubx_logs",
+    ):
+        self.mongo_client = mongo_client
+        self.db_name = db_name
+        self.collection_name = collection_name
+        self.strategy_name = strategy_name
+
+        self.collection = self.mongo_client[db_name][collection_name]
+
+    def restore_signals(self) -> dict[Instrument, list[TargetPosition]]:
+        """
+        Restore signals from MongoDB for the latest run_id.
+
+        Returns:
+            A dictionary mapping instruments to lists of signals.
+        """
+        try:
+            match_query = {
+                "log_type": "signals",
+                "strategy_name": self.strategy_name,
+            }
+
+            latest_run_doc = (
+                self.collection.find(match_query, {"run_id": 1, "timestamp": 1})
+                .sort("timestamp", -1)
+                .limit(1)
+            )
+
+            latest_run = next(latest_run_doc, None)
+            if not latest_run:
+                logger.warning("No signal logs found for given filters.")
+                return {}
+
+            latest_run_id = latest_run["run_id"]
+
+            logger.info(f"Restoring signals from MongoDB for run_id: {latest_run_id}")
+
+            query = {**match_query, "run_id": latest_run_id}
+            logs = self.collection.find(query).sort("timestamp", 1)
+
+            result: dict[Instrument, list[TargetPosition]] = {}
+
+            for log in logs:
+                try:
+                    instrument = lookup.find_symbol(log["exchange"], log["symbol"])
+                    if instrument is None:
+                        logger.warning(f"Instrument not found for {log['symbol']} on {log['exchange']}")
+                        continue
+
+                    timestamp = recognize_time(log["timestamp"])
+                    target_position_size = log.get("target_position")
+
+                    if target_position_size is None:
+                        logger.warning(f"No target_position in signal log: {log}")
+                        continue
+
+                    signal_value = log.get("signal")
+                    if signal_value is None and "side" in log:
+                        signal_value = 1.0 if str(log["side"]).lower() == "buy" else -1.0
+
+                    if signal_value is None:
+                        logger.warning(f"Missing signal or side for log: {log}")
+                        continue
+
+                    price = log.get("price") or log.get("reference_price")
+
+                    options = {}
+                    for key in ["target_position", "comment", "size", "meta"]:
+                        if key in log:
+                            options[key] = log[key]
+
+                    signal = Signal(
+                        instrument=instrument,
+                        signal=signal_value,
+                        price=price,
+                        stop=None,
+                        take=None,
+                        reference_price=log.get("reference_price"),
+                        group=log.get("group", ""),
+                        comment=log.get("comment", ""),
+                        options=options,
+                    )
+
+                    target_position = TargetPosition(
+                        time=timestamp,
+                        target_position_size=target_position_size,
+                        signal=signal,
+                    )
+
+                    result.setdefault(instrument, []).append(target_position)
+
+                except Exception as e:
+                    logger.exception(f"Failed to process signal document: {e}")
+
+            return result
+        except Exception as e:
+            logger.error(f"Error restoring signals from MongoDB: {e}")
+            return {}

qubx/restorers/state.py

@@ -7,16 +7,17 @@ from various sources.
 
 import os
 from pathlib import Path
+from pymongo import MongoClient
 
 import numpy as np
 
 from qubx import logger
 from qubx.core.basics import RestoredState
 from qubx.core.utils import recognize_time
-from qubx.restorers.balance import CsvBalanceRestorer
+from qubx.restorers.balance import CsvBalanceRestorer, MongoDBBalanceRestorer
 from qubx.restorers.interfaces import IStateRestorer
-from qubx.restorers.position import CsvPositionRestorer
-from qubx.restorers.signal import CsvSignalRestorer
+from qubx.restorers.position import CsvPositionRestorer, MongoDBPositionRestorer
+from qubx.restorers.signal import CsvSignalRestorer, MongoDBSignalRestorer
 from qubx.restorers.utils import find_latest_run_folder
 
 
@@ -112,3 +113,88 @@ class CsvStateRestorer(IStateRestorer):
             instrument_to_target_positions=target_positions,
             balances=balances,
         )
+
+
+class MongoDBStateRestorer(IStateRestorer):
+    """
+    State restorer that reads strategy state from MongoDB.
+
+    This restorer combines the functionality of MongoDBPositionRestorer,
+    MongoDBSignalRestorer, and MongoDBBalanceRestorer to create a complete RestartState.
+    """
+
+    def __init__(
+        self,
+        strategy_name: str,
+        mongo_uri: str = "mongodb://localhost:27017/",
+        db_name: str = "default_logs_db",
+        collection_name_prefix: str = "qubx_logs",
+    ):
+        self.mongo_uri = mongo_uri
+        self.db_name = db_name
+        self.collection_name_prefix = collection_name_prefix
+        self.strategy_name = strategy_name
+
+        self.client = MongoClient(mongo_uri)
+
+        # Create individual restorers
+        self.position_restorer = MongoDBPositionRestorer(
+            strategy_name=strategy_name,
+            mongo_client=self.client,
+            db_name=db_name,
+            collection_name=f"{collection_name_prefix}_positions",
+        )
+
+        self.signal_restorer = MongoDBSignalRestorer(
+            strategy_name=strategy_name,
+            mongo_client=self.client,
+            db_name=db_name,
+            collection_name=f"{collection_name_prefix}_signals",
+        )
+
+        self.balance_restorer = MongoDBBalanceRestorer(
+            strategy_name=strategy_name,
+            mongo_client=self.client,
+            db_name=db_name,
+            collection_name=f"{collection_name_prefix}_balance",
+        )
+
+    def restore_state(self) -> RestoredState:
+        """
+        Restore the complete strategy state from MongoDB.
+
+        Returns:
+            A RestoredState object containing positions, target positions, and balances.
+        """
+        mongo_collections = self.client[self.db_name].list_collection_names()
+        required_suffixes = ["positions", "signals", "balance"]
+
+        if not any(f"{self.collection_name_prefix}_{suffix}" in mongo_collections for suffix in required_suffixes):
+            logger.warning(f"No logs collections found in MongodDB {self.db_name}.")
+            self.client.close()
+            return RestoredState(
+                time=np.datetime64("now"),
+                positions={},
+                instrument_to_target_positions={},
+                balances={},
+            )
+
+        logger.info(f"Restoring state from MongoDB {self.db_name}")
+
+        positions = self.position_restorer.restore_positions()
+        target_positions = self.signal_restorer.restore_signals()
+        balances = self.balance_restorer.restore_balances()
+
+        latest_position_timestamp = (
+            max(position.last_update_time for position in positions.values()) if positions else np.datetime64("now")
+        )
+        if np.isnan(latest_position_timestamp):
+            latest_position_timestamp = np.datetime64("now")
+
+        self.client.close()
+        return RestoredState(
+            time=recognize_time(latest_position_timestamp),
+            positions=positions,
+            instrument_to_target_positions=target_positions,
+            balances=balances,
+        )

qubx/utils/runner/runner.py

@@ -1,4 +1,3 @@
-import inspect
 import socket
 import time
 from collections import defaultdict
@@ -46,6 +45,7 @@ from qubx.core.interfaces import (
 from qubx.core.loggers import StrategyLogging
 from qubx.core.lookups import lookup
 from qubx.health import BaseHealthMonitor
+from qubx.loggers import create_logs_writer
 from qubx.restarts.state_resolvers import StateResolver
 from qubx.restarts.time_finders import TimeFinder
 from qubx.restorers import create_state_restorer
@@ -388,20 +388,18 @@ def _setup_strategy_logging(
     run_id = f"{socket.gethostname()}-{str(int(time.time() * 10**9))}"
 
     _log_writer_name = log_config.logger
-    if "." not in _log_writer_name:
-        _log_writer_name = f"qubx.core.loggers.{_log_writer_name}"
 
     logger.debug(f"Setup <g>{_log_writer_name}</g> logger...")
-    _log_writer_class = class_import(_log_writer_name)
-    _log_writer_params = {
+
+    override_params = {
         "account_id": "account",
         "strategy_id": stg_name,
         "run_id": run_id,
         "log_folder": run_folder,
     }
-    _log_writer_sig_params = inspect.signature(_log_writer_class).parameters
-    _log_writer_params = {k: v for k, v in _log_writer_params.items() if k in _log_writer_sig_params}
-    _log_writer = _log_writer_class(**_log_writer_params)
+    _log_writer_params = {**override_params, **log_config.args}
+
+    _log_writer = create_logs_writer(_log_writer_name, _log_writer_params)
     stg_logging = StrategyLogging(
         logs_writer=_log_writer,
         positions_log_freq=log_config.position_interval,

{qubx-0.6.37.dist-info → qubx-0.6.38.dist-info}/METADATA

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

{qubx-0.6.37.dist-info → qubx-0.6.38.dist-info}/RECORD

@@ -7,7 +7,7 @@ qubx/backtester/data.py,sha256=De2ioNv3Zh-cCGakzK0igb2caDcqbibZ_tsYmF7sTTQ,6601
 qubx/backtester/management.py,sha256=HuyzFsBPgR7j-ei78Ngcx34CeSn65c9atmaii1aTsYg,14900
 qubx/backtester/ome.py,sha256=Uf3wqyVjUEpm1jrDQ4PE77E3R3B7wJJy1vaOOmvQqWg,15610
 qubx/backtester/optimization.py,sha256=HHUIYA6Y66rcOXoePWFOuOVX9iaHGKV0bGt_4d5e6FM,7619
-qubx/backtester/runner.py,sha256=zF56lXVRYJCBiwdqnylob-yf48r_aVK9gHpf8aT49cQ,20471
+qubx/backtester/runner.py,sha256=TnNM0t8PgBE_gnCOZZTIOc28a3RqtXmp2Xj4Gq5j6bo,20504
 qubx/backtester/simulated_data.py,sha256=niujaMRj__jf4IyzCZrSBR5ZoH1VUbvsZHSewHftdmI,17240
 qubx/backtester/simulated_exchange.py,sha256=ATGcJXnKdD47kUwgbc5tvPVL0tq4_-6jpgsTTAMxW3c,8124
 qubx/backtester/simulator.py,sha256=cSbW42X-YlAutZlOQ3Y4mAJWXr_1WomYprtWZVMe3Uk,9225
@@ -43,7 +43,7 @@ qubx/core/exceptions.py,sha256=11wQC3nnNLsl80zBqbE6xiKCqm31kctqo6W_gdnZkg8,581
 qubx/core/helpers.py,sha256=qzRsttt4sMYMarDWMzWvc3b2W-Qp9qAQwFiQBljAsA0,19722
 qubx/core/initializer.py,sha256=PUiD_cIjvGpuPjYyRpUjpwm3xNQ2Kipa8bAhbtxCQRo,3935
 qubx/core/interfaces.py,sha256=CzIl8tB6ImQkDcZEmhpstwHPOCY8NhZxXmBHLQUAieI,58253
-qubx/core/loggers.py,sha256=eYhJANHYwz1heeFMa5V7jYCL196wkTSvj6c-8lkPj1Y,19567
+qubx/core/loggers.py,sha256=0g33jfipGFShSMrXBoYVzL0GfTzI36mwBJqHNUHmhdo,13342
 qubx/core/lookups.py,sha256=n5ZjjEhhRvmidCB-Cubr1b0Opm6lf_QVZNEWa_BOQG0,19376
 qubx/core/metrics.py,sha256=Gq3Ultwn5meICfyauBUJrBS4nffSxFVH3OF6N1Y0xgo,58664
 qubx/core/mixins/__init__.py,sha256=AMCLvfNuIb1kkQl3bhCj9jIOEl2eKcVPJeyLgrkB-rk,329
@@ -52,11 +52,11 @@ qubx/core/mixins/processing.py,sha256=dqehukrfqcLy5BeILKnkpHCvva4SbLKj1ZbQdnByu1
 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=L3s2Jw46_J1iDh4622Gk_LvCjol4W7mflBwEHrLfZEw,9899
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=xDkkXCrX_5IEVqcTRyEEW_6yHElmh3wbdMOnWGrPqb0,978280
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=oCjBv31hRr3bJ47EucFuzDzwStG05dUWTNyAXBg2HwQ,978280
 qubx/core/series.pxd,sha256=jBdMwgO8J4Zrue0e_xQ5RlqTXqihpzQNu6V3ckZvvpY,3978
 qubx/core/series.pyi,sha256=RaHm_oHHiWiNUMJqVfx5FXAXniGLsHxUFOUpacn7GC0,4604
 qubx/core/series.pyx,sha256=7cM3zZThW59waHiYcZmMxvYj-HYD7Ej_l7nKA4emPjE,46477
-qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=dbfYcmWGKzRq-kIx0d7CPbIMobWlyFuRzl_oHxEtYgM,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=jpJmqz2ebCWD6_Wb8-IkGvGLhhgT2Gk0f2EmL8bkUC8,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
@@ -89,6 +89,11 @@ qubx/features/utils.py,sha256=5wMlfH4x1dUh00dxvtnHhSiHeRaiod4VMTcmgm-o_wA,264
 qubx/gathering/simplest.py,sha256=24SIjsCfutuTinSW5zSkPHGJvl-vnyhe3FAX3quUx4E,4011
 qubx/health/__init__.py,sha256=ThJTgf-CPD5tMU_emqANpnE6oXfUmzyyugfbDfzeVB0,111
 qubx/health/base.py,sha256=FmpZ7l_L-wJ8JCQ42uRjng3hAbhfmAf3nIUc4vSs9cI,27622
+qubx/loggers/__init__.py,sha256=HY26weGv_qI-i5NrvXepGCwXENOIeORW9uhvyFMVMcM,443
+qubx/loggers/csv.py,sha256=95JLFz2yxo_OjSG21cmWVYZP1XuN3V0FXNPUB_q6ucY,3791
+qubx/loggers/factory.py,sha256=09ahIIQU_59vI4OO1rKYLAHgBbZ2506wv0FqYie_Rb0,1805
+qubx/loggers/inmemory.py,sha256=49Y-jsRxDzBLWQdQMIKjVTvnx_79EbjFpHwj3v8Mgno,2642
+qubx/loggers/mongo.py,sha256=dOEpCcIxT6O9MgpK2srpzxyuto6QaQgTxMK0WcEIR70,2703
 qubx/math/__init__.py,sha256=ltHSQj40sCBm3owcvtoZp34h6ws7pZCFcSZgUkTsUCY,114
 qubx/math/stats.py,sha256=uXm4NpBRxuHFTjXERv8rjM0MAJof8zr1Cklyra4CcBA,4056
 qubx/notifications/__init__.py,sha256=2xsk3kPykiNZDZv0y4YMDbgnFvKy14SkNeg7StHk4bI,340
@@ -109,15 +114,15 @@ qubx/restarts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/restarts/state_resolvers.py,sha256=GJ617qwpulqMp_-WhpmsLozQobxgt5lU4ZGOIUaUzas,5606
 qubx/restarts/time_finders.py,sha256=r7yyRhJByV2uqdgamDRX2XClwpWWI9BNpc80t9nk6c0,2448
 qubx/restorers/__init__.py,sha256=vrnZBPJHR0-6knAccj4bK0tkjUPNRl32qiLr5Mv4aR0,911
-qubx/restorers/balance.py,sha256=ipkrRSVAscC_if6jaFtNMexHK6Z2teds2IzWdcS9yAI,3964
-qubx/restorers/factory.py,sha256=vq78vvf_ASKa-rGsV9UZlob7HCHMkiKIlLYUeCfB16g,6431
+qubx/restorers/balance.py,sha256=Oz-LY7s8tdSIJl83z9rII-DpX5xa8-qiqjcDYfW-KiE,6456
+qubx/restorers/factory.py,sha256=eoijcUHDaBVPHSfkjyo1AHvWTvvs0kj7jJbF_NE30aw,6737
 qubx/restorers/interfaces.py,sha256=CcjBWavKq8_GIMKTSPodMa-n3wJQwcQTwyvYyNo_J3c,1776
-qubx/restorers/position.py,sha256=_I_LNPXXTshxlI9hQS2ANO54JwDwseXU_PJgMmZmFCY,4764
-qubx/restorers/signal.py,sha256=DBLqA7vDhoMTAzUC4N9UerrO0GbjeHdTeMoCz7U7iI8,6621
-qubx/restorers/state.py,sha256=duXyEHQhS1zdNdo3VKscMhieZ5sYNlfE4S_pPXQ1Tuw,4109
+qubx/restorers/position.py,sha256=xmaqaQQrmzF0VEHAZK35cXb6WKYRnDDapaN-EgZcH8U,8090
+qubx/restorers/signal.py,sha256=9TAaJOEKPjZXuciFFVn6Z8a-Z8CfVSjRGFRcwEgbPLY,10745
+qubx/restorers/state.py,sha256=dLaVnUwRCNRkUqbYyi0RfZs3Q3AdglkI_qTtQ8GDD5Y,7289
 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=aQuDwEXqPC-9q3Ue_oHiyIZ-ecql-PYm_FG1yFpWfbg,654440
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=EAm2KZhw7wkpqvoEQRH9a3Z2enYqYQkk5EdVVOPuB6s,654440
 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
@@ -151,11 +156,11 @@ qubx/utils/runner/_jupyter_runner.pyt,sha256=fDj4AUs25jsdGmY9DDeSFufH1JkVhLFwy0B
 qubx/utils/runner/accounts.py,sha256=mpiv6oxr5z97zWt7STYyARMhWQIpc_XFKungb_pX38U,3270
 qubx/utils/runner/configs.py,sha256=4lonQgksh4wDygsN67lIidVRIUksskWuhL25A2IZwho,3694
 qubx/utils/runner/factory.py,sha256=vQ2dBTbrQE9YH__-TvuFzGF-E1li-vt_qQum9GHa11g,11666
-qubx/utils/runner/runner.py,sha256=TF-nD-EH8k1U2Wkjk70eEVketU6HtWpTFmFH7vjE9Z8,29298
+qubx/utils/runner/runner.py,sha256=dyrwFiVmU3nkgGiDRIg6cxhikf3KJ4ylEdojUdf9WaQ,29070
 qubx/utils/time.py,sha256=J0ZFGjzFL5T6GA8RPAel8hKG0sg2LZXeQ5YfDCfcMHA,10055
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.37.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.37.dist-info/METADATA,sha256=wxX0lvx6Mb2XSM4_ZHwHs9X_uq5qI3SG0t1IOyW-8TM,4492
-qubx-0.6.37.dist-info/WHEEL,sha256=XjdW4AGUgFDhpG9b3b2KPhtR_JLZvHyfemLgJJwcqOI,110
-qubx-0.6.37.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.37.dist-info/RECORD,,
+qubx-0.6.38.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.38.dist-info/METADATA,sha256=_71dUs78KDAbSy2GWSHBg_oTYYZnugqV8e8oACi9t-4,4492
+qubx-0.6.38.dist-info/WHEEL,sha256=XjdW4AGUgFDhpG9b3b2KPhtR_JLZvHyfemLgJJwcqOI,110
+qubx-0.6.38.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.38.dist-info/RECORD,,