Removed old unneeded blocks.

midastrader/core/adapters/base_strategy.py

@@ -1,6 +1,4 @@
 import queue
-
-# import threading
 import pandas as pd
 import importlib.util
 from typing import Type
@@ -47,7 +45,6 @@ def __init__(self, symbols_map: SymbolMap, bus: MessageBus):
         self.order_book = OrderBook.get_instance()
         self.portfolio_server = PortfolioServer.get_instance()
         self.historical_data = None
-        # self.running = threading.Event()
 
         # Subscribe to orderbook updates
         self.orderbook_queue = self.bus.subscribe(EventType.ORDER_BOOK)

midastrader/core/adapters/order_book.py

@@ -9,8 +9,6 @@
 from midastrader.structs.symbol import SymbolMap
 from midastrader.structs.events import MarketEvent, EODEvent
 from midastrader.message_bus import MessageBus, EventType
-
-# from midastrader.structs.events.base import SystemEvent
 from midastrader.core.adapters.base import CoreAdapter
 from midastrader.utils.logger import SystemLogger
 
@@ -77,7 +75,6 @@ def retrieve_all(self) -> Dict[int, RecordMsg]:
         """
         Retrieve market data for all instruments.
         """
-        # with self._lock:  # Ensure thread-safe read for a full copy
         return self._book.copy()
 
     # Methods reserved for OrderBookManager
@@ -113,11 +110,9 @@ def __init__(self, symbols_map: SymbolMap, bus: MessageBus, mode: Mode):
         super().__init__(symbols_map, bus)
         self.mode = mode
         self.book = OrderBook.get_instance()
-        # self.running = threading.Event()
 
         # Subscribe to events
         self.data_queue = self.bus.subscribe(EventType.DATA)
-        # self.equity_update_flag = self.bus.subscribe(EventType.EQUITY_UPDATED)
 
     def process(self) -> None:
         """
@@ -136,8 +131,6 @@ def process(self) -> None:
                     self.handle_record(item)
                 elif isinstance(item, EODEvent):
                     self.handle_eod(item)
-                # elif isinstance(item, RolloverEvent):
-                #     self.handle_rollover()
             except queue.Empty:
                 continue
 
@@ -147,7 +140,7 @@ def cleanup(self) -> None:
         while True:
             try:
                 item = self.data_queue.get(timeout=1)
-                if RecordMsg.is_record(item):  # isinstance(item, RecordMsg):
+                if RecordMsg.is_record(item):
                     self.handle_record(item)
                 elif isinstance(item, EODEvent):
                     self.handle_eod(item)
@@ -159,8 +152,6 @@ def cleanup(self) -> None:
 
     def handle_eod(self, event: EODEvent) -> None:
         self.logger.debug(event)
-        # Publish that EOD processing is complete
-        # processed only in backtest situations
         self.bus.publish(EventType.EOD, True)
 
         while self.bus.get_flag(EventType.EOD):
@@ -177,31 +168,19 @@ def handle_record(self, record: RecordMsg) -> None:
         self.book._update(record)
 
         # Put market event in the event queue
-        market_event = MarketEvent(
-            timestamp=record.ts_event,
-            data=record,
-        )
-
-        # self.logger.debug(market_event)  # delete
+        market_event = MarketEvent(record.ts_event, record)
 
         # Check inital data loaded
         if not self.book.tickers_loaded:
             self.book._tickers_loaded = self.check_tickers_loaded()
 
-        # Backtest only
-        # if self.mode == Mode.BACKTEST:
-
-        # Notify any observers about the market update
-        # self.bus.publish(EventType.ORDER_BOOK, market_event)
-
         if self.mode == Mode.BACKTEST:
             self.await_equity_updated()
             self.await_market_data_processed(market_event)
         else:
             self.bus.publish(EventType.ORDER_BOOK, market_event)
 
     def handle_rollover(self, record: RecordMsg) -> None:
-        # if record.rollover_flag == 1:
         id = record.hd.instrument_id
         symbol = self.symbols_map.get_symbol_by_id(id)
 
@@ -219,76 +198,6 @@ def handle_rollover(self, record: RecordMsg) -> None:
 
         self.await_rollover_flag(rollover_event)
 
-        # self.book._update(record)
-
-        # self.await_rollover_flag(rollover_event)
-
-    # def handle_event(self, event: ) -> None:
-    #     """
-    #     Handles market data events and updates the order book.
-    #
-    #     Behavior:
-    #         - Updates the order book with the new market data.
-    #         - Logs the market event.
-    #         - Checks if initial data for all tickers has been loaded.
-    #         - Notifies observers of the updated market state.
-    #
-    #     Args:
-    #         subject (Subject): The subject that triggered the event.
-    #         event_type (EventType): The type of event being handled (e.g., `MARKET_DATA`).
-    #         record (RecordMsg): The market data record to process.
-    #
-    #     """
-    #     if isinstance(event, EODEvent):
-    #         self.logger.debug(event)
-    #         # Publish that EOD processing is complete
-    #         # processed only in backtest situations
-    #         self.bus.publish(EventType.EOD, True)
-    #
-    #         while self.bus.get_flag(EventType.EOD):
-    #             continue
-    #
-    #         self.bus.publish(EventType.EOD_PROCESSED, True)
-    #         return
-    #
-    #     # if self.mode == Mode.BACKTEST:
-    #     #     if event.rollover_flag == 1:
-    #     #         rollover_event = RolloverEvent(
-    #     #             event.hd.ts_event,
-    #     #             self.symbols_map.get_symbol_by_id(event.hd.instrument_id),
-    #     #             self.book.retrieve(event.hd.instrument_id),
-    #     #             event.close,  # update
-    #     #         )
-    #     #
-    #     #         self.await_rollover_flag(rollover_event)
-    #
-    #     # Update the order book with the new market data
-    #     self.book._update(event)
-    #
-    #     # Put market event in the event queue
-    #     market_event = MarketEvent(
-    #         timestamp=event.ts_event,
-    #         data=event,
-    #     )
-    #
-    #     self.logger.debug(market_event)
-    #
-    #     # Check inital data loaded
-    #     if not self.book.tickers_loaded:
-    #         self.book._tickers_loaded = self.check_tickers_loaded()
-    #
-    #     # Backtest only
-    #     # if self.mode == Mode.BACKTEST:
-    #
-    #     # Notify any observers about the market update
-    #     # self.bus.publish(EventType.ORDER_BOOK, market_event)
-    #
-    #     if self.mode == Mode.BACKTEST:
-    #         self.await_equity_updated()
-    #         self.await_market_data_processed(market_event)
-    #     else:
-    #         self.bus.publish(EventType.ORDER_BOOK, market_event)
-
     def check_tickers_loaded(self) -> bool:
         """
         Checks if market data for all tickers in the symbol map has been loaded.
@@ -300,13 +209,6 @@ def check_tickers_loaded(self) -> bool:
             self.book._book.keys()
         )
 
-    # def await_updates(self):
-    #     """
-    #     Waits for the EOD_PROCESSED flag to be set.
-    #     """
-    #     self.await_equity_updated()
-    #     self.await_system_updated()
-
     def await_rollover_flag(
         self,
         event: RolloverEvent,

midastrader/core/adapters/order_manager.py

@@ -32,7 +32,6 @@ def __init__(self, symbols_map: SymbolMap, bus: MessageBus):
         super().__init__(symbols_map, bus)
         self.order_book = OrderBook.get_instance()
         self.portfolio_server = PortfolioServer.get_instance()
-        # self.running = threading.Event()
 
         # Subcriptions
         self.signal_queue = self.bus.subscribe(EventType.SIGNAL)
@@ -68,7 +67,7 @@ def process(self) -> None:
 
         self.cleanup()
 
-    def cleanup(self):
+    def cleanup(self) -> None:
         while True:
             try:
                 event = self.signal_queue.get(timeout=1)
@@ -152,29 +151,14 @@ def _handle_signal(
 
                 if not order:
                     self.logger.warning(
-                        f"Skipping order {signal.signal_id}: error creating order."
+                        f"Error creating order {signal.signal_id}."
                     )
                     return
-                #
-                # if current_price is None:
-                #     self.logger.warning(
-                #         f"Skipping trade {trade.trade_id}: No current price for {symbol.instrument_id}"
-                #     )
-                #     return
-
                 order_cost = symbol.cost(
                     float(order.quantity),
                     current_price.pretty_price,
                 )
 
-                # order_details = {
-                #     "timestamp": timestamp,
-                #     # "signal_id": signal.signal_id,
-                #     # "action": signal.action,
-                #     # "symbol": symbol,
-                #     "order": order,
-                # }
-                #
                 orders.append(order)
 
                 # SELL/Cover are exits so available capital will be freed up
@@ -187,27 +171,12 @@ def _handle_signal(
                 )
 
         if total_capital_required <= self.portfolio_server.capital:
-            # for order in orders:
             self._set_order(timestamp, orders)
-
-            # order["timestamp"],
-            #     order["signal_id"],
-            #     order["action"],
-            #     order["symbol"],
-            #     order["order"],
-            # )
         else:
-            self.logger.debug("Not enough capital to execute all orders")
+            self.logger.info("Not enough capital to execute all orders")
             self.bus.publish(EventType.UPDATE_SYSTEM, False)
 
-    def _set_order(
-        self,
-        timestamp: int,
-        # signal_id: int,
-        # action: Action,
-        # symbol: Symbol,
-        orders: List[BaseOrder],
-    ) -> None:
+    def _set_order(self, timestamp: int, orders: List[BaseOrder]) -> None:
         """
         Queues an OrderEvent for execution based on the provided order details.
 
@@ -223,14 +192,7 @@ def _set_order(
             RuntimeError: If creating the `OrderEvent` fails due to invalid input or unexpected errors.
         """
         try:
-            order_event = OrderEvent(
-                timestamp=timestamp,
-                # signal_id=signal_id,
-                # action=action,
-                # symbol=symbol,
-                orders=orders,
-            )
-            self.logger.info(order_event)
+            order_event = OrderEvent(timestamp, orders)
             self.bus.publish(EventType.ORDER, order_event)
         except (ValueError, TypeError) as e:
             raise RuntimeError(f"Failed to set OrderEvent due to input : {e}")

midastrader/core/adapters/performance/base.py

@@ -88,7 +88,6 @@ def __init__(
         self.output_dir = output_dir
         self._strategy: Optional[BaseStrategy] = None
         self.threads = []
-        # self.running = threading.Event()
 
         # Subscribe to events
         self.account_queue = self.bus.subscribe(EventType.ACCOUNT_UPDATE_LOG)