How to prevent my "sell to close" option order from being exercised?

In QuantConnect, if you hold a long position in an Option that expires in the money, LEAN automatically exercises it at the expiration date. This is mentioned in the forum discussion by Mia Alissi. If you don't want this automatic exercise, you can sell the Option or let it expire worthless if it's out of the money. Here is how you can exercise an Option in Python:

ticket = self.ExerciseOption(contract_symbol, quantity)

If you do not have sufficient capital for the order, it's rejected. By default, Option exercise orders are synchronous and fill immediately.

However, if you're seeing the P&L continue to change after the expiration of the option, it might be a bug or an issue with your specific algorithm. It would be helpful to review your code and ensure that you're correctly handling the expiration and exercise of options.

For more details, you can refer to the QuantConnect Documentation.

In your case, it seems like you are trying to sell the option to close the position. However, if the option is in the money and it's close to the expiration date, LEAN might be automatically exercising it. You might want to adjust your algorithm to sell the option well before the expiration date to avoid automatic exercise.

Is there not a way to override this LEAN behavior? Seems like automatically exercising options when closing a trade (especially when an account is not large enough) is not a good replication of a live market scenario with a real broker. How do people scalp options with this platform?

Yes, there is a way to override the automatic exercise of options in LEAN. You can implement a custom Option Exercise Model. This allows you to define your own rules for when and how options should be exercised.

In C#, you can use the SetOptionExerciseModel method of the Option object to set the exercise model. Here is an example from the QuantConnect Documentation:

// In Initialize
SetSecurityInitializer(new MySecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));

// Outside of the algorithm class
class MySecurityInitializer : BrokerageModelSecurityInitializer
{
 public MySecurityInitializer(IBrokerageModel brokerageModel, ISecuritySeeder securitySeeder)
 : base(brokerageModel, securitySeeder) {} 

 public override void Initialize(Security security)
 {
 // First, call the superclass definition
 // This method sets the reality models of each security using the default reality models of the brokerage model
 base.Initialize(security);

 // Next, overwrite the Option exercise model 
 if (security.Type == SecurityType.Option) // Option type
 {
 (security as Option).SetOptionExerciseModel(new DefaultExerciseModel());
 } 
 }
}

In Python, you can do the same with the SetOptionExerciseModel method:

# In Initialize
self.SetSecurityInitializer(MySecurityInitializer(self.BrokerageModel, FuncSecuritySeeder(self.GetLastKnownPrices)))

# Outside of the algorithm class
class MySecurityInitializer(BrokerageModelSecurityInitializer):

 def __init__(self, brokerage_model: IBrokerageModel, security_seeder: ISecuritySeeder) -> None:
 super().__init__(brokerage_model, security_seeder)

 def Initialize(self, security: Security) -> None:
 # First, call the superclass definition
 # This method sets the reality models of each security using the default reality models of the brokerage model
 super().Initialize(security)

 # Next, overwrite the Option exercise model 
 if security.Type == SecurityType.Option: # Option type
 security.SetOptionExerciseModel(DefaultExerciseModel())

You can also disable the automatic assignment by using the SetOptionAssignmentModel method with NullOptionAssignmentModel() as mentioned in the forum discussion:

security.SetOptionAssignmentModel(NullOptionAssignmentModel())

This should give you more control over when options are exercised and allow you to better replicate live market scenarios.

For future reference, it wasn't explicitly stated anywhere really, but this is the code that worked for me:

I'm glad to hear that you found a solution that works for you! The code you linked to is a Python implementation of a custom option exercise model in QuantConnect's LEAN engine. This allows you to define your own rules for when and how options should be exercised, giving you more control over your algorithm's behavior.

For anyone else who might be facing a similar issue, you can check out the CustomOptionExerciseModelRegressionAlgorithm.py on QuantConnect's GitHub page. This script provides a good example of how to implement a custom option exercise model in Python.

Remember, the key part is to override the OptionExerciseModel with your own custom model. This can be done using the SetOptionExerciseModel method of the Option object:

self.option.SetOptionExerciseModel(CustomOptionExerciseModel())

In the custom model, you can define your own logic for when an option should be exercised. For example, in the linked script, the OptionExerciseModel.ShouldExercise method is overridden to prevent automatic exercise of options:

class CustomOptionExerciseModel(OptionExerciseModel):
    def ShouldExercise(self, option, marketData):
        return False

This effectively disables automatic exercise of options, giving you full control over when and how options are exercised in your algorithm.