Market order error

from AlgorithmImports import *

class DebugMarketOrderAlgorithm(QCAlgorithm):
    """
    Helper algorithm that embeds a comprehensive debug checklist and
    diagnostic utilities to troubleshoot the Python error:
        unsupported operand type(s) for *: 'float' and 'MarketOrder'

    HOW TO USE IN YOUR OWN PROJECT
    1.  Copy–paste the two public methods below into your QCAlgorithm:
        • debug_market_order_state(...)
        • __init__/initialize contents storing self._original_market_order_ref
    2.  Call   self.debug_market_order_state(symbol, quantity)
        immediately before each self.market_order(symbol, quantity) call.
    3.  Inspect the Debug-log output; follow any WARN/ERROR messages.

    The minimal demo below fires once every day, 15 min before the close.
    """

    def initialize(self) -> None:
        # 1️⃣  Basic setup
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100_000)

        # Ensure the security is added before scheduling events
        self._symbol = self.add_equity("SPY", Resolution.MINUTE).symbol

        # Preserve the original QCAlgorithm.market_order reference
        self._original_market_order_ref = self.market_order

        # Demo schedule – replace with your own timing logic
        self.schedule.on(
            self.date_rules.every_day(self._symbol),
            self.time_rules.before_market_close(self._symbol, 15),
            self._scheduled_trade,
        )

    # ────────────────────────────────────────────────────────────────
    # PUBLIC HELPER – PASTE INTO YOUR OWN ALGORITHM AS-IS
    # ────────────────────────────────────────────────────────────────
    def debug_market_order_state(self, symbol: Symbol, quantity: int) -> None:
        """6-point diagnostic checklist executed right before placing an order."""
        # 0️⃣ Log the raw intent
        self.debug(f"[0] About to place MarketOrder: symbol={symbol}, "
                   f"quantity={quantity} (quantity_type={type(quantity).__name__})")

        # 1️⃣ Validate self.market_order is still a callable method
        market_order_attr = getattr(self, "market_order", None)
        if market_order_attr is None:
            self.debug("[1] FATAL: self.market_order attribute missing!")
        elif callable(market_order_attr):
            self.debug(f"[1] OK: self.market_order is callable. object={market_order_attr}")
        else:
            self.debug("[1] ERROR: self.market_order is *not* callable; "
                       f"actual_type={type(market_order_attr).__name__}. "
                       "Search for accidental reassignment.")

        # 2️⃣ Detect accidental reassignment of the original method
        if market_order_attr is not self._original_market_order_ref:
            self.debug("[2] WARNING: self.market_order was re-bound. "
                       "Look for `market_order = ...` in your code.")
        else:
            self.debug("[2] OK: self.market_order still points to the original method.")

        # 3️⃣ Search for shadowing variables named “market_order”
        shadow_hits = []
        scopes = [("globals", globals())]
        self_dict = getattr(self, "__dict__", None)
        if isinstance(self_dict, dict):
            scopes.append(("self.__dict__", self_dict))
        for scope_name, scope in scopes:
            if "market_order" in scope and scope["market_order"] is not market_order_attr:
                shadow_hits.append((scope_name, scope["market_order"]))
        if shadow_hits:
            for scope_name, obj in shadow_hits:
                self.debug(f"[3] WARNING: `{scope_name}['market_order']` shadows the "
                           f"method. value={obj} (type={type(obj).__name__})")
        else:
            self.debug("[3] OK: No shadowing variables named 'market_order'.")

        # 4️⃣ Inspect fill / slippage models for custom behaviour
        security = self.securities.get(symbol)
        if security is None:
            self.debug(f"[4] ERROR: {symbol} not found in self.securities. Did you add it?")
        else:
            fill_model_name = security.fill_model.__class__.__name__
            slippage_model_name = (security.slippage_model.__class__.__name__
                                   if security.slippage_model else "None")
            self.debug(f"[4] INFO: fill_model={fill_model_name}, "
                       f"slippage_model={slippage_model_name}")
            default_models = {"ImmediateFillModel",
                              "VolumeShareSlippageModel",
                              "SpreadSlippageModel"}
            if (fill_model_name not in default_models or
                    slippage_model_name not in default_models):
                self.debug("[4] WARNING: Custom fill/slippage model detected. "
                           "Ensure it returns numeric values, not MarketOrder objects.")

        # 5️⃣ Sanity-check the quantity argument
        if not isinstance(quantity, int):
            self.debug(f"[5] WARNING: quantity is not int; received "
                       f"{type(quantity).__name__}.")
        if quantity == 0:
            self.debug("[5] WARNING: quantity == 0; no order will be submitted.")

        # 6️⃣ Static-code-review reminder
        self.debug("[6] ACTION: If the error persists, search your project for "
                   "'MarketOrder' being multiplied or added. Ex: `x * MarketOrder(...)` "
                   "or functions returning a MarketOrder where a float is expected.")

    # ────────────────────────────────────────────────────────────────
    # DEMO SCHEDULED TRADE (REMOVE IN YOUR OWN CODE)
    # ────────────────────────────────────────────────────────────────
    def _scheduled_trade(self) -> None:
        quantity: int = 10
        self.debug_market_order_state(self._symbol, quantity)  # Diagnostics
        self.market_order(self._symbol, quantity)              # Real order

How to use this to debug your issue:

1. Copy the debug_market_order_state method and the assignment of self._original_market_order_ref into your initialize() into your own algorithm.
2. Place a call to self.debug_market_order_state(symbol1, quantity1) immediately before every self.market_order(...) call.
3. Run a backtest and look at the Debug output. The diagnostic printouts will guide you to:
   • accidental method overwrites,
   • variable shadowing,
   • custom fill/execution model issues,
   • misuse of MarketOrder objects,
   • argument type problems.
4. If there is a warning or error in the logs, follow its advice. If all steps are “OK” and the crash persists, reduce your code to the smallest script that triggers the bug for further isolation.

Bonus manual checklist:

• Review your project for lines like market_order = ..., def market_order(, or MarketOrder( used on the right side of a multiplication (*) operator.
• Confirm no part of your code stores the result of self.market_order(...) and then performs arithmetic on it.
• If you use custom fill models or order handling, ensure you never return a MarketOrder object instead of a numeric fill quantity or price.

This methodical approach should help you pin down what's hijacking the market order flow!

Sources: docs writing algorithms trading and orders order errors, docs writing algorithms live trading notifications, docs writing algorithms live trading brokerages, Stop Market Orders - QuantConnect.com, Key Concepts - QuantConnect.com