Puzzling problem with Tags

Based on the information provided in the extracts, it seems that the tag parameter in the MarketOrder function is not supported as a named parameter. This was mentioned in a forum discussion from August 2020. The correct syntax to include a tag for a MarketOrder would be self.MarketOrder(ticker/symbol, quantity, False, tag string).

However, it's important to note that the tag parameter is not used to differentiate between different types of orders (like main, stop loss, or take profit orders). Instead, it's used to add a note or comment to the order.

If you want to manage different types of orders separately, you might want to consider using different variables to store the order tickets for each type of order. For example, you could use mainOrderTicket, stopLossOrderTicket, and takeProfitOrderTicket to store the order tickets for the main order, stop loss order, and take profit order respectively.

Here's an example of how you could do this:

mainOrderTicket = self.MarketOrder(symbol, quantity)
stopLossOrderTicket = self.StopMarketOrder(symbol, -quantity, stopLossPrice)
takeProfitOrderTicket = self.LimitOrder(symbol, -quantity, takeProfitPrice)

Then, in the OnOrderEvent method, you can check the OrderId of the orderEvent against the OrderId of each order ticket to determine which type of order has been filled:

def OnOrderEvent(self, orderEvent):
    if orderEvent.Status == OrderStatus.Filled:
        if orderEvent.OrderId == mainOrderTicket.OrderId:
            self.Debug("Main order filled")
        elif orderEvent.OrderId == stopLossOrderTicket.OrderId:
            self.Debug("Stop loss order filled")
        elif orderEvent.OrderId == takeProfitOrderTicket.OrderId:
            self.Debug("Take profit order filled")

This way, you can keep track of each type of order separately and handle them accordingly in your algorithm.

2 problems with Mia's answer. 

First, ‘she’ is referring to the same 2020 post that says named parameters are not supported, but there have been subsequent posts recommending named parameters. And my testing indicates the Tag normally does work when specified as a named parameter.

Second: I agree that would be the most straightforward way to code it - having separate variables (or dictionary items) to keep track of the main, SL, TP orders. But I am trying to build a robust system that runs correctly across broker reconnects and even program restarts. So by using tags I can always infer the system state from examining the open orders, and incoming order events. 

I apologize for the confusion. If your testing indicates that the tag parameter works as a named parameter, then you should continue using it as such. The information in the extracts might be outdated or incorrect.

As for your second point, using tags to manage your orders across broker reconnects and program restarts is indeed a good strategy. However, it seems there's an issue with the tag being appended with additional information like "- Oanda Fill Event". This behavior is not explicitly documented in the provided extracts.

One possible workaround could be to parse the tag in your OnOrderEvent method to extract the original tag. Here's an example:

def OnOrderEvent(self, orderEvent: OrderEvent) -> None:
    tag = orderEvent.Ticket.Tag
    original_tag = tag.split(' - ')[0]
    self.Log(f"<{original_tag}>")

This code splits the tag string at ' - ' and takes the first part, which should be your original tag.

However, this is just a workaround and might not work in all cases. It would be best to contact QuantConnect support for a more definitive solution to this issue. You can reach them at support@quantconnect.com.

As for the issue of order tags not being restored upon algorithm restart, it seems to be a known issue based on a Github issue from the extracts. A potential solution suggested in the comments of the issue is to pull the order information from cloud storage, match by brokerage id, and attempt to map the order tags back to the order. However, this solution has not been implemented yet. You might want to follow this issue for updates or contact QuantConnect support for more information.

Sorry one more thing. Everything worked fine in testing. It is only since I deployed my program Live I am having this problem. It's almost certainly related to connecting to Oanda vs. the LEAN engine ‘simulating’ Oanda. And since I am only seeing the problem in Live trading it's very difficult to experiment to narrow this down.

"As for the issue of order tags not being restored upon algorithm restart, it seems to be a known issue based on a Github issue from the extracts."

Ah, that changes everything. Now there is no reason for me to use tags at all. I will implement your previous suggestion.

I'm glad to hear that you found the information useful. Implementing separate variables for each type of order (main, stop loss, take profit) can indeed be a good strategy for managing your orders. Here's the example code again for your reference:

mainOrderTicket = self.MarketOrder(symbol, quantity)
stopLossOrderTicket = self.StopMarketOrder(symbol, -quantity, stopLossPrice)
takeProfitOrderTicket = self.LimitOrder(symbol, -quantity, takeProfitPrice)

And in the OnOrderEvent method:

def OnOrderEvent(self, orderEvent):
    if orderEvent.Status == OrderStatus.Filled:
        if orderEvent.OrderId == mainOrderTicket.OrderId:
            self.Debug("Main order filled")
        elif orderEvent.OrderId == stopLossOrderTicket.OrderId:
            self.Debug("Stop loss order filled")
        elif orderEvent.OrderId == takeProfitOrderTicket.OrderId:
            self.Debug("Take profit order filled")

This way, you can keep track of each type of order separately and handle them accordingly in your algorithm. If you have any more questions or run into any issues, feel free to ask.