opstrat

Use multi_plotter() to visualize complex strategies involving multiple simultaneous option positions. This function plots each individual payoff diagram alongside the resultant combined payoff diagram.

Arguments:

• spot: The current price of the underlying asset.
• op_list: A list of dictionaries, where each dictionary defines an individual option's parameters.
• spot_range: (Optional) Limits the range of spot values covered in the plot. The default is +/-20%. Use smaller values (e.g., 5) for low volatility or larger values for high volatility assets.

Each dictionary in op_list must contain:

• op_type: 'c' (call) or 'p' (put).
• strike: The strike price.
• tr_type: 'b' (buy) or 's' (sell).
• op_pr: The option premium.

import opstrat as op

# Example: Short Strangle
op_1 = {'op_type':'c', 'strike':110, 'tr_type':'s', 'op_pr':2}
op_2 = {'op_type':'p', 'strike':95, 'tr_type':'s', 'op_pr':6}

op.multi_plotter(spot=100, op_list=[op_1, op_2])

# Example: Iron Condor
op1={'op_type': 'c', 'strike': 215, 'tr_type': 's', 'op_pr': 7.63}
op2={'op_type': 'c', 'strike': 220, 'tr_type': 'b', 'op_pr': 5.35}
op3={'op_type': 'p', 'strike': 210, 'tr_type': 's', 'op_pr': 7.20}
op4={'op_type': 'p', 'strike': 205, 'tr_type': 'b', 'op_pr': 5.52}

op.multi_plotter(spot=212.26, spot_range=10, op_list=[op1, op2, op3, op4])

Use single_plotter() to generate a payoff diagram for a single option position. The plot uses Green for profit and Red for loss.

Parameters:

• op_type: 'c' for call option, 'p' for put option (default: 'c')
• spot: Spot Price (default: 100)
• spot_range: Range of spot variation in percentage (default: 5)
• strike: Strike Price (default: 102)
• tr_type: Transaction Type, 'b' for long, 's' for short (default: 'b')
• op_pr: Option Price/Premium (default: 10)
• save: Boolean, set to True to save the figure
• file: Filename with extension to save the figure (e.g., 'plot.png'). If not provided, defaults to fig.png.

import opstrat as op

# Default plot
op.single_plotter()

# Custom plot: Short Put
op.single_plotter(spot=460, strike=460, op_type='p', tr_type='s', op_pr=12.5)

# Save a custom plot
op.single_plotter(save=True, file='simple_option.jpeg')

Use multi_plotter() to plot payoff diagrams for strategies involving multiple options (e.g., Strangles, Iron Condors).

Parameters:

• spot: Spot Price (default: 100)
• spot_range: Range of spot variation in percentage (default: 20)
• op_list: A list of dictionaries, where each dictionary represents one option in the strategy. Each dictionary must contain:
  • strike: Strike Price
  • tr_type: 'b' (long) or 's' (short)
  • op_pr: Option Price/Premium
  • op_type: 'c' (call) or 'p' (put)

import opstrat as op

# Example: Iron Condor (4 options)
op1={'op_type': 'c', 'strike': 215, 'tr_type': 's', 'op_pr': 7.63}
op2={'op_type': 'c', 'strike': 220, 'tr_type': 'b', 'op_pr': 5.35}
op3={'op_type': 'p', 'strike': 210, 'tr_type': 's', 'op_pr': 7.20}
op4={'op_type': 'p', 'strike': 205, 'tr_type': 'b', 'op_pr': 5.52}

op_list=[op1, op2, op3, op4]
op.multi_plotter(spot=212.26, spot_range=10, op_list=op_list)

Use yf_plotter() to generate payoff diagrams using real-world market data via the Yahoo Finance API. This allows you to specify a stock ticker and an expiration date.

Arguments:

• ticker: The stock ticker symbol (e.g., 'msft', 'amzn').
• exp: The option expiry date in 'YYYY-MM-DD' format.
• op_list: A list of dictionaries defining the options (e.g., {'tr_type':'b', 'op_type':'c', 'strike':235}).
• spot_range: (Optional) The range of spot values to cover in the plot.

import opstrat as op

# Example: Call Option Buyer for Microsoft
op_list=[{'tr_type':'b', 'op_type':'c', 'strike':235}]
op.yf_plotter('msft', spot_range=10, op_list=op_list)

# Example: Strangle on Amazon with specific expiry
op_1={'op_type': 'c', 'strike':3150, 'tr_type': 'b'}
op_2={'op_type': 'p', 'strike':3150, 'tr_type': 'b'}
op.yf_plotter(ticker='amzn', exp='2021-03-26', op_list=[op_1, op_2])

To visualize how Greeks change as time to expiration approaches, iterate through a range of time values (ts) and different volatility levels (vs), collecting the results into a pandas DataFrame for plotting with matplotlib.

Note: When plotting time-decay, it is common to use plt.gca().invert_xaxis() to show time moving towards expiration.

import opstrat as op
import pandas as pd
import matplotlib.pyplot as plt

K=100
St=95
r=4
vs=[10,25,40,60]
ts=[i for i in range(1,101)]
type='c'

df_list=[]
for v in vs:
    vals, vals_int, vals_time = [], [], []
    deltas, gammas, thetas, rhos, vegas = [], [], [], [], []
    
    for t in ts:
        params = op.black_scholes(t=t, K=K, St=St, r=r, v=v, type=type)
        vals.append(params['value']['option value'])
        vals_int.append(params['value']['intrinsic value'])
        vals_time.append(params['value']['time value'])
        deltas.append(params['greeks']['delta'])
        gammas.append(params['greeks']['gamma'])
        thetas.append(params['greeks']['theta'])
        rhos.append(params['greeks']['rho'])
        vegas.append(params['greeks']['vega'])
        
    df = pd.DataFrame({
        'vals': vals, 'vals_int': vals_int, 'vals_time': vals_time,
        'delta': deltas, 'gamma': gammas, 'theta': thetas,
        'rho': rhos, 'vega': vegas
    })
    df_list.append(df)

# Plotting Delta across different volatilities
for greek in ['delta', 'gamma', 'theta', 'rho', 'vega']:
    plt.figure(figsize=(10,6))
    for df, v in zip(df_list, vs):
        plt.plot(ts, df[greek], label=f'{greek} V:{v}%')
    plt.gca().invert_xaxis()
    plt.legend()
    plt.show()