All open orders from IB

from AlgorithmImports import *
class MyAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        # ------------------------------------------------
        # Basic algorithm setup (back-test dates & assets)
        # ------------------------------------------------
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.add_equity("SPY", Resolution.DAILY)

        # Run the check every day, 10 minutes after market open
        self.schedule.on(
            self.date_rules.every_day("SPY"),
            self.time_rules.after_market_open("SPY", 10),
            self.fetch_ib_order_details
        )

    # --------------------------------------------------------
    #  IB data fetcher – only valid when running LIVE on IB
    # --------------------------------------------------------
    def fetch_ib_order_details(self) -> None:
        """
        Retrieve Interactive Brokers open orders and current account
        holdings, then compare the IB positions against QC’s Portfolio
        to detect outside trades (trades placed directly in TWS).

        Notes
        -----
        • Executes ONLY in live mode; back-tests lack an IB connection.
        • Uses `self.brokerage` (lower-case) per QuantConnect standard.
        • All external calls are wrapped in try/except for safety.
        • Results are logged via self.debug for easy review.
        """
        # 1. Ensure we are live
        if not self.live_mode:
            self.debug("fetch_ib_order_details: not in live mode – skipped.")
            return

        # 2. Access the brokerage object
        brokerage = getattr(self, "brokerage", None)
        if brokerage is None:
            self.debug("Interactive Brokers connection not found.")
            return

        # 3. ---------------------  Fetch open orders  ---------------------
        try:
            open_orders = brokerage.get_open_orders()
            self.debug(f"IB open orders fetched: {len(open_orders)} order(s).")
        except Exception as exc:
            self.debug(f"IB open order retrieval failed: {exc}")
            open_orders = []

        # 4. ---------------------  Fetch account holdings  -----------------
        try:
            ib_holdings = brokerage.get_account_holdings()
            self.debug(f"IB holdings fetched: {len(ib_holdings)} symbol(s).")
        except Exception as exc:
            self.debug(f"IB holding retrieval failed: {exc}")
            ib_holdings = []

        # 5. -------------  Compare IB holdings vs QC Portfolio -------------
        for ib_holding in ib_holdings:
            symbol = ib_holding.symbol
            ib_qty = ib_holding.quantity

            qc_qty = self.portfolio[symbol].quantity if symbol in self.portfolio else 0

            if qc_qty != ib_qty:
                self.debug(
                    f"Outside trade/mismatch detected → "
                    f"{symbol.value}: IB Qty={ib_qty}, QC Qty={qc_qty}"
                )

Key points in this version:

• Uses self.brokerage (not self.Brokerage), which is the QuantConnect live brokerage instance.
• Uses get_open_orders() and get_account_holdings() methods (not PascalCase).
• Checks self.live_mode and logs/returns if running in backtest.
• Logs all fetched and compared information.
• Handles all exceptions gracefully and logs issues for review.
• Compares the holdings between IB and QuantConnect, logging discrepancies which could indicate external trades.

This should help Dharmesh reliably and cleanly fetch IB status and detect outside orders when running live with Interactive Brokers on QuantConnect.

Sources: docs writing algorithms live trading commands, Live Features Algorithm, docs writing algorithms datasets quantconnect binance crypto future margin rate data, docs writing algorithms datasets coinapi binance crypto future price data, docs writing algorithms universes equity cfd

Validate below complete code

 def fetch_ib_order_details(self):
        

        if not self.live_mode:
            self.debug("fetch_ib_order_details: not in live mode – skipped.")
            return

        brokerage = getattr(self, "brokerage", None)
        if brokerage is None:
            self.Debug("Brokerage connection not available. Cannot fetch IB orders.")
            return

        # --- Retrieve open orders ---
        try:
            orders = brokerage.get_open_orders()
        except Exception as e:
            self.Debug(f"Failed to retrieve open orders from brokerage: {str(e)}")
            orders = []

        for order in orders:
            try:
                symbol = order.Symbol.Value if hasattr(order.Symbol, "Value") else str(order.Symbol)
                qty = order.Quantity
                entry_price = getattr(order, "AverageFillPrice", None) or getattr(order, "LimitPrice", None)
                entry_price = entry_price or getattr(order, "StopPrice", None)
                buy_date = getattr(order, "Time", None)
                stop_loss = getattr(order, "StopPrice", None)
                profit_target = getattr(order, "LimitPrice", None)

                self.Debug(
                    f"IB Order - Symbol:{symbol} Qty:{qty} Price:{entry_price} Date:{buy_date} "
                    f"SL:{stop_loss} TP:{profit_target}"
                )
            except Exception as ex:
                self.Debug(f"Error processing IB order: {str(ex)}")

        # --- Retrieve account holdings ---
        try:
            holdings = brokerage.get_account_holdings()
        except Exception as e:
            self.Debug(f"Failed to retrieve account holdings from brokerage: {str(e)}")
            holdings = []

        holdings_symbols = set()
        for holding in holdings:
            try:
                symbol = holding.Symbol.Value if hasattr(holding.Symbol, "Value") else str(holding.Symbol)
                qty = holding.Quantity
                price = holding.AveragePrice
                holdings_symbols.add(symbol)

                self.Debug(f"IB Holding - Symbol:{symbol} Qty:{qty} AvgPrice:{price}")
            except Exception as ex:
                self.Debug(f"Error processing IB holding: {str(ex)}")