Qubx 0.6.49__tar.gz → 0.6.52__tar.gz

{qubx-0.6.49 → qubx-0.6.52}/PKG-INFO

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

{qubx-0.6.49 → qubx-0.6.52}/pyproject.toml

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

{qubx-0.6.49 → qubx-0.6.52}/src/qubx/backtester/data.py

@@ -139,26 +139,31 @@ class SimulatedDataProvider(IDataProvider):
         bars = []
 
         # - if no records, return empty list to avoid exception from infer_series_frequency
-        if not records:
+        if not records or records is None:
             return bars
 
-        _data_tf = infer_series_frequency([r.time for r in records[:50]])
-        timeframe_ns = _data_tf.item()
-
-        if records is not None:
-            for r in records:
-                # _b_ts_0 = np.datetime64(r.time, "ns").item()
-                _b_ts_0 = r.time
-                _b_ts_1 = _b_ts_0 + timeframe_ns - self._open_close_time_indent_ns
-
-                if _b_ts_0 <= cut_time_ns and cut_time_ns < _b_ts_1:
-                    break
-
-                bars.append(
-                    Bar(
-                        _b_ts_0, r.data["open"], r.data["high"], r.data["low"], r.data["close"], r.data.get("volume", 0)
-                    )
+        if len(records) > 1:
+            _data_tf = infer_series_frequency([r.time for r in records[:50]])
+            timeframe_ns = _data_tf.item()
+
+        for r in records:
+            _b_ts_0 = r.time
+            _b_ts_1 = _b_ts_0 + timeframe_ns - self._open_close_time_indent_ns
+
+            if _b_ts_0 <= cut_time_ns and cut_time_ns < _b_ts_1:
+                break
+
+            bars.append(
+                Bar(
+                    _b_ts_0,
+                    r.data["open"],
+                    r.data["high"],
+                    r.data["low"],
+                    r.data["close"],
+                    r.data.get("volume", 0),
+                    r.data.get("bought_volume", 0),
                 )
+            )
 
         return bars
 

{qubx-0.6.49 → qubx-0.6.52}/src/qubx/backtester/simulator.py

@@ -48,6 +48,7 @@ def simulate(
     portfolio_log_freq: str = "5Min",
     parallel_backend: Literal["loky", "multiprocessing"] = "multiprocessing",
     emission: EmissionConfig | None = None,
+    run_separate_instruments: bool = False,
 ) -> list[TradingSessionResult]:
     """
     Backtest utility for trading strategies or signals using historical data.
@@ -73,6 +74,7 @@ def simulate(
         - portfolio_log_freq (str): Frequency for portfolio logging, default is "5Min".
         - parallel_backend (Literal["loky", "multiprocessing"]): Backend for parallel processing, default is "multiprocessing".
         - emission (EmissionConfig | None): Configuration for metric emitters, default is None.
+        - run_separate_instruments (bool): If True, creates separate simulation setups for each instrument, default is False.
 
     Returns:
         - list[TradingSessionResult]: A list of TradingSessionResult objects containing the results of each simulation setup.
@@ -109,6 +111,7 @@ def simulate(
         commissions=commissions,
         signal_timeframe=signal_timeframe,
         accurate_stop_orders_execution=accurate_stop_orders_execution,
+        run_separate_instruments=run_separate_instruments,
     )
     if not simulation_setups:
         logger.error(
@@ -117,6 +120,10 @@ def simulate(
         )
         raise SimulationError(_msg)
 
+    # - inform about separate instruments mode
+    if run_separate_instruments and len(simulation_setups) > 1:
+        logger.info(f"Running separate simulations for each instrument. Total simulations: {len(simulation_setups)}")
+
     # - preprocess start and stop and convert to datetime if necessary
     if stop is None:
         # - check stop time : here we try to backtest till now (may be we need to get max available time from data reader ?)
@@ -160,24 +167,50 @@ def _run_setups(
     _main_loop_silent = len(strategies_setups) == 1
     n_jobs = 1 if _main_loop_silent else n_jobs
 
-    reports = ProgressParallel(
-        n_jobs=n_jobs, total=len(strategies_setups), silent=_main_loop_silent, backend=parallel_backend
-    )(
-        delayed(_run_setup)(
-            id,
-            f"Simulated-{id}",
-            setup,
-            data_setup,
-            start,
-            stop,
-            silent,
-            show_latency_report,
-            portfolio_log_freq,
-            emission,
+    if n_jobs == 1:
+        reports = [
+            _run_setup(
+                id,
+                f"Simulated-{id}",
+                setup,
+                data_setup,
+                start,
+                stop,
+                silent,
+                show_latency_report,
+                portfolio_log_freq,
+                emission,
+            )
+            for id, setup in enumerate(strategies_setups)
+        ]
+    else:
+        reports = ProgressParallel(
+            n_jobs=n_jobs, total=len(strategies_setups), silent=_main_loop_silent, backend=parallel_backend
+        )(
+            delayed(_run_setup)(
+                id,
+                f"Simulated-{id}",
+                setup,
+                data_setup,
+                start,
+                stop,
+                silent,
+                show_latency_report,
+                portfolio_log_freq,
+                emission,
+            )
+            for id, setup in enumerate(strategies_setups)
         )
-        for id, setup in enumerate(strategies_setups)
-    )
-    return reports  # type: ignore
+
+    # Filter out None results and log warnings for failed simulations
+    successful_reports = []
+    for i, report in enumerate(reports):
+        if report is None:
+            logger.warning(f"Simulation setup {i} failed - skipping from results")
+        else:
+            successful_reports.append(report)
+
+    return successful_reports
 
 
 def _run_setup(
@@ -191,48 +224,58 @@ def _run_setup(
     show_latency_report: bool,
     portfolio_log_freq: str,
     emission: EmissionConfig | None = None,
-) -> TradingSessionResult:
-    # Create metric emitter if configured
-    emitter = None
-    if emission is not None:
-        emitter = create_metric_emitters(emission, setup.name)
-
-    runner = SimulationRunner(
-        setup=setup,
-        data_config=data_setup,
-        start=start,
-        stop=stop,
-        account_id=account_id,
-        portfolio_log_freq=portfolio_log_freq,
-        emitter=emitter,
-    )
+) -> TradingSessionResult | None:
+    try:
+        # Create metric emitter if configured
+        emitter = None
+        if emission is not None:
+            emitter = create_metric_emitters(emission, setup.name)
 
-    # - we want to see simulate time in log messages
-    QubxLogConfig.setup_logger(
-        level=QubxLogConfig.get_log_level(), custom_formatter=SimulatedLogFormatter(runner.ctx).formatter
-    )
+        runner = SimulationRunner(
+            setup=setup,
+            data_config=data_setup,
+            start=start,
+            stop=stop,
+            account_id=account_id,
+            portfolio_log_freq=portfolio_log_freq,
+            emitter=emitter,
+        )
 
-    runner.run(silent=silent)
-
-    # - service latency report
-    if show_latency_report:
-        runner.print_latency_report()
-
-    return TradingSessionResult(
-        setup_id,
-        setup.name,
-        start,
-        stop,
-        setup.exchanges,
-        setup.instruments,
-        setup.capital,
-        setup.base_currency,
-        setup.commissions,
-        runner.logs_writer.get_portfolio(as_plain_dataframe=True),
-        runner.logs_writer.get_executions(),
-        runner.logs_writer.get_signals(),
-        strategy_class=runner.strategy_class,
-        parameters=runner.strategy_params,
-        is_simulation=True,
-        author=get_current_user(),
-    )
+        # - we want to see simulate time in log messages
+        QubxLogConfig.setup_logger(
+            level=QubxLogConfig.get_log_level(), custom_formatter=SimulatedLogFormatter(runner.ctx).formatter
+        )
+
+        runner.run(silent=silent)
+
+        # - service latency report
+        if show_latency_report:
+            runner.print_latency_report()
+
+        # Convert commissions to the expected type for TradingSessionResult
+        commissions_for_result = setup.commissions
+        if isinstance(commissions_for_result, dict):
+            # Filter out None values to match TradingSessionResult expected type
+            commissions_for_result = {k: v for k, v in commissions_for_result.items() if v is not None}
+
+        return TradingSessionResult(
+            setup_id,
+            setup.name,
+            start,
+            stop,
+            setup.exchanges,
+            setup.instruments,
+            setup.capital,
+            setup.base_currency,
+            commissions_for_result,
+            runner.logs_writer.get_portfolio(as_plain_dataframe=True),
+            runner.logs_writer.get_executions(),
+            runner.logs_writer.get_signals(),
+            strategy_class=runner.strategy_class,
+            parameters=runner.strategy_params,
+            is_simulation=True,
+            author=get_current_user(),
+        )
+    except Exception as e:
+        logger.error(f"Simulation setup {setup_id} failed with error: {e}")
+        return None

{qubx-0.6.49 → qubx-0.6.52}/src/qubx/backtester/utils.py

@@ -419,6 +419,7 @@ def recognize_simulation_configuration(
     commissions: str | dict[str, str | None] | None,
     signal_timeframe: str,
     accurate_stop_orders_execution: bool,
+    run_separate_instruments: bool = False,
 ) -> list[SimulationSetup]:
     """
     Recognize and create setups based on the provided simulation configuration.
@@ -438,6 +439,7 @@ def recognize_simulation_configuration(
     - commissions (str): The commission structure to be applied.
     - signal_timeframe (str): Timeframe for generated signals.
     - accurate_stop_orders_execution (bool): If True, enables more accurate stop order execution simulation.
+    - run_separate_instruments (bool): If True, creates separate setups for each instrument.
 
     Returns:
     - list[SimulationSetup]: A list of SimulationSetup objects, each representing a
@@ -458,7 +460,7 @@ def recognize_simulation_configuration(
             r.extend(
                 recognize_simulation_configuration(
                     _n + n, v, instruments, exchanges, capital, basic_currency, commissions, 
-                    signal_timeframe, accurate_stop_orders_execution
+                    signal_timeframe, accurate_stop_orders_execution, run_separate_instruments
                 )
             )
 
@@ -474,45 +476,85 @@ def recognize_simulation_configuration(
                 _t = SetupTypes.STRATEGY_AND_TRACKER
 
             # - extract actual symbols that have signals
-            r.append(
-                SimulationSetup(
-                    _t, name, _s, c1,   # type: ignore
-                    _sniffer._pick_instruments(instruments, _s) if _sniffer._is_signal(c0) else instruments,
-                    exchanges, capital, basic_currency, commissions, 
-                    signal_timeframe, accurate_stop_orders_execution
+            setup_instruments = _sniffer._pick_instruments(instruments, _s) if _sniffer._is_signal(c0) else instruments
+            
+            if run_separate_instruments:
+                # Create separate setups for each instrument
+                for instrument in setup_instruments:
+                    r.append(
+                        SimulationSetup(
+                            _t, f"{name}/{instrument.symbol}", _s, c1,   # type: ignore
+                            [instrument],
+                            exchanges, capital, basic_currency, commissions, 
+                            signal_timeframe, accurate_stop_orders_execution
+                        )
+                    )
+            else:
+                r.append(
+                    SimulationSetup(
+                        _t, name, _s, c1,   # type: ignore
+                        setup_instruments,
+                        exchanges, capital, basic_currency, commissions, 
+                        signal_timeframe, accurate_stop_orders_execution
+                    )
                 )
-            )
         else:
             for j, s in enumerate(configs):
                 r.extend(
                     recognize_simulation_configuration(
                         # name + "/" + str(j), s, instruments, exchange, capital, basic_currency, commissions
                         name, s, instruments, exchanges, capital, basic_currency, commissions,  # type: ignore
-                        signal_timeframe, accurate_stop_orders_execution
+                        signal_timeframe, accurate_stop_orders_execution, run_separate_instruments
                     )
                 )
 
     elif _sniffer._is_strategy(configs):
-        r.append(
-            SimulationSetup(
-                SetupTypes.STRATEGY,
-                name, configs, None, instruments,
-                exchanges, capital, basic_currency, commissions, 
-                signal_timeframe, accurate_stop_orders_execution
+        if run_separate_instruments:
+            # Create separate setups for each instrument
+            for instrument in instruments:
+                r.append(
+                    SimulationSetup(
+                        SetupTypes.STRATEGY,
+                        f"{name}/{instrument.symbol}", configs, None, [instrument],
+                        exchanges, capital, basic_currency, commissions, 
+                        signal_timeframe, accurate_stop_orders_execution
+                    )
+                )
+        else:
+            r.append(
+                SimulationSetup(
+                    SetupTypes.STRATEGY,
+                    name, configs, None, instruments,
+                    exchanges, capital, basic_currency, commissions, 
+                    signal_timeframe, accurate_stop_orders_execution
+                )
             )
-        )
 
     elif _sniffer._is_signal(configs):
         # - check structure of signals
         c1 = _sniffer._check_signals_structure(instruments, configs)  # type: ignore
-        r.append(
-            SimulationSetup(
-                SetupTypes.SIGNAL,
-                name, c1, None, _sniffer._pick_instruments(instruments, c1),
-                exchanges, capital, basic_currency, commissions, 
-                signal_timeframe, accurate_stop_orders_execution
+        setup_instruments = _sniffer._pick_instruments(instruments, c1)
+        
+        if run_separate_instruments:
+            # Create separate setups for each instrument
+            for instrument in setup_instruments:
+                r.append(
+                    SimulationSetup(
+                        SetupTypes.SIGNAL,
+                        f"{name}/{instrument.symbol}", c1, None, [instrument],
+                        exchanges, capital, basic_currency, commissions, 
+                        signal_timeframe, accurate_stop_orders_execution
+                    )
+                )
+        else:
+            r.append(
+                SimulationSetup(
+                    SetupTypes.SIGNAL,
+                    name, c1, None, setup_instruments,
+                    exchanges, capital, basic_currency, commissions, 
+                    signal_timeframe, accurate_stop_orders_execution
+                )
             )
-        )
 
     # fmt: on
     return r

{qubx-0.6.49 → qubx-0.6.52}/src/qubx/core/loggers.py

@@ -10,10 +10,8 @@ from qubx.core.basics import (
     Position,
     TargetPosition,
 )
-
 from qubx.core.series import time_as_nsec
 from qubx.core.utils import recognize_timeframe
-
 from qubx.utils.misc import Stopwatch
 from qubx.utils.time import convert_tf_str_td64, floor_t64
 
@@ -21,14 +19,14 @@ _SW = Stopwatch()
 
 
 class LogsWriter:
-    account_id: str
-    strategy_id: str
-    run_id: str
-
     """
     Log writer interface with default implementation
     """
 
+    account_id: str
+    strategy_id: str
+    run_id: str
+
     def __init__(self, account_id: str, strategy_id: str, run_id: str) -> None:
         self.account_id = account_id
         self.strategy_id = strategy_id

{qubx-0.6.49 → qubx-0.6.52}/src/qubx/core/mixins/processing.py

@@ -39,7 +39,8 @@ from qubx.core.series import Bar, OrderBook, Quote, Trade
 
 
 class ProcessingManager(IProcessingManager):
-    MAX_NUMBER_OF_STRATEGY_FAILURES = 10
+    MAX_NUMBER_OF_STRATEGY_FAILURES: int = 10
+    DATA_READY_TIMEOUT_SECONDS: int = 60
 
     _context: IStrategyContext
     _strategy: IStrategy
@@ -67,6 +68,7 @@ class ProcessingManager(IProcessingManager):
     _trig_bar_freq_nsec: int | None = None
     _cur_sim_step: int | None = None
     _updated_instruments: set[Instrument] = set()
+    _data_ready_start_time: dt_64 | None = None
 
     def __init__(
         self,
@@ -111,6 +113,7 @@ class ProcessingManager(IProcessingManager):
         self._strategy_name = strategy.__class__.__name__
         self._trig_bar_freq_nsec = None
         self._updated_instruments = set()
+        self._data_ready_start_time = None
 
     def set_fit_schedule(self, schedule: str) -> None:
         rule = process_schedule_spec(schedule)
@@ -344,9 +347,56 @@ class ProcessingManager(IProcessingManager):
 
     def _is_data_ready(self) -> bool:
         """
-        Check if at least one update was received for all instruments in the context.
+        Check if strategy can start based on data availability with timeout logic.
+
+        Two-phase approach:
+        - Phase 1 (0-DATA_READY_TIMEOUT_SECONDS): Wait for ALL instruments to have data
+        - Phase 2 (after timeout): Wait for at least 1 instrument to have data
+
+        Returns:
+            bool: True if strategy can start, False if still waiting
         """
-        return all(instrument in self._updated_instruments for instrument in self._context.instruments)
+        total_instruments = len(self._context.instruments)
+
+        # Handle edge case: no instruments
+        if total_instruments == 0:
+            return True
+
+        ready_instruments = len(self._updated_instruments)
+
+        # Record start time on first call
+        if self._data_ready_start_time is None:
+            self._data_ready_start_time = self._time_provider.time()
+
+        # Phase 1: Try to get all instruments ready within timeout
+        elapsed_time_seconds = (self._time_provider.time() - self._data_ready_start_time) / 1e9
+
+        if elapsed_time_seconds <= self.DATA_READY_TIMEOUT_SECONDS:
+            # Within timeout period - wait for ALL instruments
+            if ready_instruments == total_instruments:
+                logger.info(f"All {total_instruments} instruments have data - strategy ready to start")
+                return True
+            else:
+                # Log periodic status during Phase 1
+                if int(elapsed_time_seconds) % 10 == 0 and elapsed_time_seconds > 0:  # Log every 10 seconds
+                    missing_instruments = set(self._context.instruments) - self._updated_instruments
+                    missing_symbols = [inst.symbol for inst in missing_instruments]
+                    logger.info(
+                        f"Phase 1: Waiting for all instruments ({ready_instruments}/{total_instruments} ready). "
+                        f"Missing: {missing_symbols}. Timeout in {self.DATA_READY_TIMEOUT_SECONDS - elapsed_time_seconds}s"
+                    )
+                return False
+        else:
+            # Phase 2: After timeout - need at least 1 instrument
+            if ready_instruments >= 1:
+                missing_instruments = set(self._context.instruments) - self._updated_instruments
+                missing_symbols = [inst.symbol for inst in missing_instruments]
+                logger.info(
+                    f"Starting strategy with {ready_instruments}/{total_instruments} instruments ready. Missing: {missing_symbols}"
+                )
+                return True
+            else:
+                return False
 
     def __update_base_data(
         self, instrument: Instrument, event_type: str, data: Timestamped, is_historical: bool = False

{qubx-0.6.49 → qubx-0.6.52}/src/qubx/core/mixins/universe.py

@@ -114,11 +114,12 @@ class UniverseManager(IUniverseManager):
                 self._removal_queue.pop(instr)
 
     def add_instruments(self, instruments: list[Instrument]):
-        self.__do_add_instruments(instruments)
+        to_add = list(set([instr for instr in instruments if instr not in self._instruments]))
+        self.__do_add_instruments(to_add)
         self.__cleanup_removal_queue(instruments)
-        self._strategy.on_universe_change(self._context, instruments, [])
+        self._strategy.on_universe_change(self._context, to_add, [])
         self._subscription_manager.commit()
-        self._instruments.update(instruments)
+        self._instruments.update(to_add)
 
     def remove_instruments(
         self,

{qubx-0.6.49 → qubx-0.6.52}/src/qubx/data/composite.py

@@ -71,12 +71,15 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
         return self
 
     def _build_initial_iteration_seq(self):
-        _init_seq = {k: self._time_func(self._buffers[k][-1]) for k in self._keys}
+        _init_seq = {k: self._time_func(self._buffers[k][-1]) for k in self._keys if self._buffers[k]}
         _init_seq = dict(sorted(_init_seq.items(), key=lambda item: item[1]))
         self._keys = deque(_init_seq.keys())
 
     def _load_next_chunk_to_buffer(self, index: str) -> list[Timestamped]:
-        return list(reversed(next(self._iterators[index])))
+        try:
+            return list(reversed(next(self._iterators[index])))
+        except StopIteration:
+            return []
 
     def _remove_iterator(self, key: str):
         self._buffers.pop(key)
@@ -95,6 +98,9 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
         Returns:
             Timestamped: The most recent timestamped data element from the buffer.
         """
+        if not self._buffers[k]:
+            raise StopIteration
+
         v = (data := self._buffers[k]).pop()
         if not data:
             try:
@@ -154,6 +160,9 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
         _min_t = math.inf
         _min_k = self._keys[0]
         for i in self._keys:
+            if not self._buffers[i]:
+                continue
+
             _x = self._buffers[i][-1]
             if self._time_func(_x) < _min_t:
                 _min_t = self._time_func(_x)

{qubx-0.6.49 → qubx-0.6.52}/src/qubx/data/readers.py

@@ -1469,6 +1469,11 @@ class QuestDBConnector(DataReader):
             # Use efficient chunking with multiple smaller queries
             def _iter_efficient_chunks():
                 time_windows = _calculate_time_windows_for_chunking(start, end, effective_timeframe, chunksize)
+                if self._connection is None:
+                    self._connect()
+                    if self._connection is None:
+                        raise ConnectionError("Failed to connect to QuestDB")
+
                 _cursor = self._connection.cursor()  # type: ignore
 
                 try:

{qubx-0.6.49 → qubx-0.6.52}/src/qubx/emitters/base.py

@@ -207,6 +207,6 @@ class BaseMetricEmitter(IMetricEmitter):
         elapsed = current_time - self._last_emission_time
 
         if elapsed >= self._stats_interval:
-            logger.debug(f"[{self.__class__.__name__}] Emitting metrics at {current_time}")
+            # logger.debug(f"[{self.__class__.__name__}] Emitting metrics at {current_time}")
             self.emit_strategy_stats(context)
             self._last_emission_time = current_time

{qubx-0.6.49 → qubx-0.6.52}/src/qubx/loggers/csv.py

@@ -6,7 +6,8 @@ from multiprocessing.pool import ThreadPool
 
 from qubx import logger
 from qubx.core.loggers import LogsWriter
-from qubx.utils.misc import  makedirs
+from qubx.utils.misc import makedirs
+
 
 class CsvFileLogsWriter(LogsWriter):
     """
@@ -97,4 +98,3 @@ class CsvFileLogsWriter(LogsWriter):
         self._sig_file_.close()
         self.pool.close()
         self.pool.join()
-

{qubx-0.6.49 → qubx-0.6.52}/src/qubx/loggers/factory.py

@@ -1,19 +1,19 @@
 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
+from qubx.loggers.mongo import MongoDBLogsWriter
 
 # Registry of logs writer types
 LOGS_WRITER_REGISTRY: dict[str, Type[LogsWriter]] = {
     "CsvFileLogsWriter": CsvFileLogsWriter,
     "MongoDBLogsWriter": MongoDBLogsWriter,
-    "InMemoryLogsWriter": InMemoryLogsWriter
+    "InMemoryLogsWriter": InMemoryLogsWriter,
 }
 
+
 def create_logs_writer(log_writer_type: str, parameters: dict | None = None) -> LogsWriter:
     """
     Create a logs writer based on configuration.
@@ -30,8 +30,7 @@ def create_logs_writer(log_writer_type: str, parameters: dict | None = None) ->
     """
     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())}"
+            f"Unknown logs writer type: {log_writer_type}. Available types: {', '.join(LOGS_WRITER_REGISTRY.keys())}"
         )
 
     logs_writer_class = LOGS_WRITER_REGISTRY[log_writer_type]
@@ -52,4 +51,4 @@ def register_logs_writer(log_writer_type: str, logs_witer_class: Type[LogsWriter
         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
+    LOGS_WRITER_REGISTRY[log_writer_type] = logs_witer_class