Building a Bear Call Spread Class

1. Understanding the Bear Call Spread

Before we write any code, let's quickly review the Bear Call Spread. It's a credit spread strategy used when you have a neutral to bearish outlook on an underlying asset. The goal is for the asset's price to stay below the strike price of the call option you sell.

A bear call spread is constructed by:

1. Selling a call option with a strike price (K1) that is out-of-the-money (above the current stock price). This generates a premium.
2. Buying a call option with a higher strike price (K2) and the same expiration date. This serves as protection and defines the maximum loss.

The net result is a credit received, which is also the maximum potential profit.

The payoff diagram from the article shows a limited profit and limited loss profile, which is exactly what we want to create with our code.

2. Structuring the BearCallSpread Class

Just like with BullPutSpread, our new class will inherit from the abstract Strategy class. This means it must provide a concrete implementation for any abstract methods defined in the parent, like find_trade_opportunity.

The concept of creating a specialized subclass that inherits common functionality but adds its own specific behavior is fundamental to object-oriented programming.

Now, let's define the skeleton for our BearCallSpread class. The __init__ method will look very similar to the one for the BullPutSpread, taking a symbol and a dictionary of parameters. The key difference will be the default delta ranges, which are now for call options.

# In framework/strategies.py
from .base import Strategy # Assuming Strategy ABC is in base.py

class BearCallSpread(Strategy):
    """
    A concrete implementation of a Bear Call Spread strategy.
    """
    def __init__(self, symbol: str, params: dict):
        """
        Initializes the BearCallSpread strategy.

        Args:
            symbol (str): The underlying symbol for the strategy.
            params (dict): A dictionary of strategy-specific parameters.
        """
        super().__init__(name=f"BearCallSpread_{symbol}")
        self.symbol = symbol
        
        # Unpack parameters with default values
        self.min_dte = params.get('min_dte', 21)
        self.max_dte = params.get('max_dte', 60)
        self.oi_threshold = params.get('oi_threshold', 50)
        self.strike_range_pct = params.get('strike_range_pct', 0.06)
        
        # Criteria for selecting the short and long call legs
        # For OTM calls, delta is positive and ranges from 0 to 1.
        self.criteria = params.get('criteria', {
            'short_call': {'delta': (0.15, 0.40)},  # Delta range for the call we sell
            'long_call':  {'delta': (0.05, 0.20)}   # Delta range for the call we buy
        })

    def find_trade_opportunity(self, data_handler, analytics_engine):
        """
        Finds a suitable Bear Call Spread trade based on market data and criteria.
        
        This method will contain the core logic for selecting the two call options.
        """
        # ... Core logic to find the spread will go here ...
        
        return None # Placeholder

Notice the new criteria for the deltas. For a bear call spread, we sell a call that is closer to the money (higher delta) and buy one that is further out-of-the-money (lower delta).

3. Implementing the Core Logic: find_trade_opportunity

This is where we implement the heart of the strategy. The workflow is almost identical to the BullPutSpread, which demonstrates the power of our framework's design. The main differences are:

1. We fetch call options instead of puts.
2. We use the delta criteria defined for calls.
3. The pairing logic is reversed to satisfy the conditions of a bear call spread.

Here is the full implementation of the BearCallSpread class, including all the necessary helper methods adapted for this strategy. Pay close attention to the comments highlighting the key changes from the previous lesson.

# In framework/strategies.py (full class implementation)

class BearCallSpread(Strategy):
    """
    A concrete implementation of a Bear Call Spread strategy.
    """
    def __init__(self, symbol: str, params: dict):
        super().__init__(name=f"BearCallSpread_{symbol}")
        self.symbol = symbol
        self.min_dte = params.get('min_dte', 21)
        self.max_dte = params.get('max_dte', 60)
        self.oi_threshold = params.get('oi_threshold', 50)
        self.strike_range_pct = params.get('strike_range_pct', 0.10) # Wider range for calls
        self.criteria = params.get('criteria', {
            'short_call': {'delta': (0.15, 0.40)},
            'long_call':  {'delta': (0.05, 0.20)}
        })

    def find_trade_opportunity(self, data_handler, analytics_engine):
        """
        Orchestrates the workflow to find a bear call spread.
        """
        # 1. Get underlying price
        underlying_price = data_handler.get_latest_price(self.symbol)
        if underlying_price is None:
            print(f"Could not fetch price for {self.symbol}")
            return None

        # 2. Get all available CALL options within DTE and strike range
        # --- CHANGE: Fetch 'call' options ---
        call_options = data_handler.get_option_chain(
            underlying_symbol=self.symbol,
            min_dte=self.min_dte,
            max_dte=self.max_dte,
            strike_range_pct=self.strike_range_pct,
            option_type='call' # Key change here
        )

        # 3. Process options to find candidates
        short_call_candidates = []
        long_call_candidates = []

        for option_contract in call_options:
            if not self._validate_liquidity(option_contract, data_handler):
                continue
            
            option_with_analytics = analytics_engine.get_analytics(option_contract)
            if option_with_analytics is None:
                continue

            if self._check_candidate_conditions(option_with_analytics, 'short_call'):
                short_call_candidates.append(option_with_analytics)
            
            if self._check_candidate_conditions(option_with_analytics, 'long_call'):
                long_call_candidates.append(option_with_analytics)

        # 4. Pair candidates to find a valid spread
        selected_spread = self._pair_candidates(short_call_candidates, long_call_candidates, underlying_price)

        if selected_spread:
            print(f"Found valid Bear Call Spread for {self.symbol}:")
            print(f"  Short Call: {selected_spread['short_leg']['symbol']}")
            print(f"  Long Call:  {selected_spread['long_leg']['symbol']}")
            return selected_spread
        
        print(f"No valid Bear Call Spread found for {self.symbol}")
        return None

    # --- Helper Methods ---

    def _validate_liquidity(self, option_contract, data_handler) -> bool:
        """Checks if the option meets the open interest threshold."""
        open_interest = data_handler.get_open_interest(option_contract)
        return open_interest is not None and open_interest > self.oi_threshold

    def _check_candidate_conditions(self, option_with_analytics: dict, leg_type: str) -> bool:
        """Check if a candidate option meets the filtering criteria for a given leg."""
        delta_range = self.criteria[leg_type]['delta']
        delta = option_with_analytics['greeks']['delta']
        
        return delta_range[0] <= delta <= delta_range[1]

    def _pair_candidates(self, short_calls: list, long_calls: list, underlying_price: float) -> dict or None:
        """
        Pairs short and long call candidates to form a valid spread.
        
        --- CHANGE: Logic for a Bear Call Spread ---
        We require:
        - Same expiration date.
        - underlying_price < short_call_strike < long_call_strike
        """
        for sc in short_calls:
            for lc in long_calls:
                # Must have same expiration
                if sc['expiration_date'] != lc['expiration_date']:
                    continue
                
                # Check strike price condition for a bear call spread
                sc_strike = sc['strike_price']
                lc_strike = lc['strike_price']
                if (underlying_price < sc_strike < lc_strike):
                    # Found a valid pair
                    return {'short_leg': sc, 'long_leg': lc}
        
        return None

Conclusion

Excellent work! We have now successfully implemented the BearCallSpread class. By building upon the structure from the previous lesson, you've seen firsthand how a well-designed framework allows for rapid extension. We now have two distinct, interchangeable strategies ready to be deployed by our system.

Key Takeaways:

• The BearCallSpread class was created by inheriting from the abstract Strategy class, just like its bullish counterpart.
• We adapted the __init__ method with parameters and delta criteria specific to a bearish call spread.
• The core logic in find_trade_opportunity was easily adapted by changing the option type to 'call' and modifying the pairing logic to underlying_price < short_call_strike < long_call_strike.
• This process reinforces the power of the Strategy design pattern: the "context" (our main event loop) can use either BullPutSpread or BearCallSpread without knowing the internal details of how they work, as long as they both provide a find_trade_opportunity method.

Preview of the Next Lesson:
In this lesson and the last, we've used delta ranges to filter for potential legs. In our next lesson, we will develop logic within each class to select appropriate strike prices based on delta and spread width. This will refine our selection process, allowing us to specify not just the delta of the short leg, but also the exact desired width of the spread (e.g., a $5 wide spread), making our strategy's risk profile even more precise.