Daily Put Selling Bracket Orders

Based on the provided code, it seems like the BracketOrder class is not fully implemented. The __init__ method is defined, but there are no other methods in the class to handle the creation and management of the bracket orders.

In the main.py file, a BracketOrder object is created with this line:

BracketOrder(self, put_to_sell.Symbol, -1, ask_price, ask_price, stop_loss_price, take_profit_price)

However, this object is not assigned to any variable, and no methods are called on it. This means that the bracket order is not actually being placed in the market.

To implement bracket orders, you need to create a class that initiates and handles all new bracket orders. This class should have methods for creating the initial order, as well as the stop loss and take profit orders. It should also have a method for handling order events, to ensure that when one part of the bracket order is filled, the other parts are cancelled.

Here is an example of how you might implement this, based on the information provided in the extracts:

class BracketOrder:
    def __init__(self, algorithm, symbol, totQuantity, placementPrice, limitPrice, stopPrice, profitPrice):
        self.algorithm = algorithm
        self.symbol = symbol
        self.totQuantity = totQuantity
        self.placementPrice = placementPrice
        self.limitPrice = limitPrice
        self.stopPrice = stopPrice
        self.profitPrice = profitPrice
        self.entryTicket = None
        self.stopLossTicket = None
        self.takeProfitTicket = None

    def placeOrder(self):
        self.entryTicket = self.algorithm.MarketOrder(self.symbol, self.totQuantity)
        self.stopLossTicket = self.algorithm.StopMarketOrder(self.symbol, -self.totQuantity, self.stopPrice)
        self.takeProfitTicket = self.algorithm.LimitOrder(self.symbol, -self.totQuantity, self.profitPrice)

    def onOrderEvent(self, orderEvent):
        if orderEvent.Status == OrderStatus.Filled:
            if orderEvent.OrderId == self.entryTicket.OrderId:
                self.placeOrder()
            elif orderEvent.OrderId == self.stopLossTicket.OrderId or orderEvent.OrderId == self.takeProfitTicket.OrderId:
                self.algorithm.Transactions.CancelOpenOrders(self.symbol)

In this example, the placeOrder method is used to place the initial order, as well as the stop loss and take profit orders. The onOrderEvent method is used to handle order events. When the initial order is filled, it places the stop loss and take profit orders. When either the stop loss or take profit order is filled, it cancels any remaining open orders for the symbol.

Please note that this is just a basic example, and you may need to modify it to fit your specific needs. For example, you might want to add error checking to ensure that orders are only placed if there is sufficient buying power, or to handle cases where the initial order is not filled.

Mia Alissi After making the changes the orders are being placed however, the opposing stop loss or take profits are not being cancelled when the other order is filled. In the class BracketOrder def onOrderEvent there is logic that should cancel the opposing order but this does not occur. 

 

Based on the provided code, it seems like the issue might be related to the order in which the orders are being placed and the order events are being handled.

In the placeOrder method of the BracketOrder class, the entry order, stop loss order, and take profit order are all placed at the same time:

def placeOrder(self):
    self.entryTicket = self.algorithm.MarketOrder(self.symbol, self.totQuantity)
    self.stopLossTicket = self.algorithm.StopMarketOrder(self.symbol, -self.totQuantity, self.stopPrice)
    self.takeProfitTicket = self.algorithm.LimitOrder(self.symbol, -self.totQuantity, self.profitPrice)

However, in the onOrderEvent method, the code only checks if the filled order is the entry order, and if it is, it returns without doing anything:

def onOrderEvent(self, orderEvent):
    if orderEvent.Status == OrderStatus.Filled:
        if orderEvent.OrderId == self.entryTicket.OrderId:
          return

This means that if the entry order is filled before the stop loss and take profit orders are placed, the onOrderEvent method will return before it has a chance to cancel the other orders.

One possible solution to this issue is to only place the stop loss and take profit orders after the entry order has been filled. This can be done by moving the code to place these orders into the onOrderEvent method, like so:

def onOrderEvent(self, orderEvent):
    if orderEvent.Status == OrderStatus.Filled:
        if orderEvent.OrderId == self.entryTicket.OrderId:
            self.stopLossTicket = self.algorithm.StopMarketOrder(self.symbol, -self.totQuantity, self.stopPrice)
            self.takeProfitTicket = self.algorithm.LimitOrder(self.symbol, -self.totQuantity, self.profitPrice)
        elif orderEvent.OrderId == self.stopLossTicket.OrderId or orderEvent.OrderId == self.takeProfitTicket.OrderId:
             if self.stopLossTicket is not None and self.takeProfitTicket is not None:
                 if orderEvent.OrderId == self.stopLossTicket.OrderId:
                      self.algorithm.Transactions.CancelOrder(self.takeProfitTicket.OrderId)
                 elif orderEvent.OrderId == self.takeProfitTicket.OrderId:
                      self.algorithm.Transactions.CancelOrder(self.stopLossTicket.OrderId)

This way, the stop loss and take profit orders are only placed after the entry order is filled, and the onOrderEvent method can correctly handle the cancellation of the other orders when one of them is filled.