AI Newsletter Digest improvements: fixed QP soft line break decoding, URL extraction, and content cleaning
This commit is contained in:
Krilly
469
skills/options-strategy-advisor/README.md
Normal file
469
skills/options-strategy-advisor/README.md
Normal file
@@ -0,0 +1,469 @@
|
||||
# Options Strategy Advisor
|
||||
|
||||
Educational options trading tool providing theoretical pricing, strategy analysis, and risk management guidance using Black-Scholes model.
|
||||
|
||||
## Overview
|
||||
|
||||
Options Strategy Advisor helps traders understand and analyze options strategies without requiring expensive real-time options data. It uses theoretical pricing models (Black-Scholes) combined with free stock market data (FMP API) to simulate strategies and calculate Greeks.
|
||||
|
||||
**Key Features:**
|
||||
- ✅ Black-Scholes pricing engine
|
||||
- ✅ All Greeks calculation (Delta, Gamma, Theta, Vega, Rho)
|
||||
- ✅ 17+ options strategies supported
|
||||
- ✅ P/L simulation and visualization
|
||||
- ✅ Earnings strategy integration
|
||||
- ✅ Historical volatility calculation
|
||||
- ✅ Risk management guidance
|
||||
|
||||
## Why This Approach?
|
||||
|
||||
**No expensive data subscriptions needed:**
|
||||
- Real-time options data: $99-$500/month (Polygon.io, Intrinio)
|
||||
- FMP API Free tier: $0/month (250 requests/day)
|
||||
|
||||
**Educational focus:**
|
||||
- Learn how strategies work
|
||||
- Understand Greeks and risk metrics
|
||||
- Compare strategies side-by-side
|
||||
|
||||
**Practical application:**
|
||||
- Theoretical prices ≈ market mid-prices
|
||||
- User can input actual IV from broker
|
||||
- Good for strategy planning and education
|
||||
|
||||
## Supported Strategies
|
||||
|
||||
### Income Strategies
|
||||
1. **Covered Call** - Generate income from stock holdings
|
||||
2. **Cash-Secured Put** - Get paid to buy stock
|
||||
3. **Poor Man's Covered Call** - Capital-efficient covered call
|
||||
|
||||
### Protection Strategies
|
||||
4. **Protective Put** - Insurance for stock positions
|
||||
5. **Collar** - Limited risk/reward protection
|
||||
|
||||
### Directional Strategies
|
||||
6. **Bull Call Spread** - Limited risk bullish play
|
||||
7. **Bull Put Spread** - Credit spread for bullish view
|
||||
8. **Bear Call Spread** - Credit spread for bearish view
|
||||
9. **Bear Put Spread** - Limited risk bearish play
|
||||
|
||||
### Volatility Strategies
|
||||
10. **Long Straddle** - Profit from big moves
|
||||
11. **Long Strangle** - Cheaper straddle, bigger move needed
|
||||
12. **Short Straddle** - Profit from no movement (high risk)
|
||||
13. **Short Strangle** - Wider range straddle
|
||||
|
||||
### Range-Bound Strategies
|
||||
14. **Iron Condor** - Profit from range-bound trading
|
||||
15. **Iron Butterfly** - Tight range profit
|
||||
|
||||
### Advanced Strategies
|
||||
16. **Calendar Spread** - Time decay play
|
||||
17. **Diagonal Spread** - Directional + time decay
|
||||
|
||||
## Installation
|
||||
|
||||
### Prerequisites
|
||||
- Python 3.8+
|
||||
- FMP API key (free tier sufficient)
|
||||
|
||||
### Install Dependencies
|
||||
```bash
|
||||
pip install numpy scipy requests pandas
|
||||
```
|
||||
|
||||
### Get FMP API Key
|
||||
1. Visit https://financialmodelingprep.com/developer/docs
|
||||
2. Sign up for free account
|
||||
3. Copy API key
|
||||
4. Set environment variable:
|
||||
```bash
|
||||
export FMP_API_KEY="your_key_here"
|
||||
```
|
||||
|
||||
## Quick Start
|
||||
|
||||
### Test Black-Scholes Pricer
|
||||
|
||||
```bash
|
||||
python scripts/black_scholes.py
|
||||
```
|
||||
|
||||
**Example Output:**
|
||||
```
|
||||
BLACK-SCHOLES OPTIONS PRICER - EXAMPLE
|
||||
======================================================================
|
||||
|
||||
Input Parameters:
|
||||
Stock Price: $180.00
|
||||
Strike Price: $185.00
|
||||
Days to Expiration: 30
|
||||
Volatility: 25.0%
|
||||
Risk-Free Rate: 5.30%
|
||||
Dividend Yield: 1.0%
|
||||
|
||||
======================================================================
|
||||
CALL OPTION
|
||||
======================================================================
|
||||
Price: $2.45
|
||||
Intrinsic Value: $0.00
|
||||
Time Value: $2.45
|
||||
|
||||
Greeks:
|
||||
Delta: 0.3654 ($36.54 per $1 move)
|
||||
Gamma: 0.0234 (delta changes by 0.0234)
|
||||
Theta: -$0.18/day (loses $0.18 per day)
|
||||
Vega: $0.25 per 1% IV (gains $0.25 if IV +1%)
|
||||
Rho: $0.12 per 1% rate (gains $0.12 if rate +1%)
|
||||
```
|
||||
|
||||
### Use in Your Code
|
||||
|
||||
```python
|
||||
from scripts.black_scholes import OptionPricer
|
||||
|
||||
# Initialize pricer
|
||||
pricer = OptionPricer(
|
||||
S=180, # Stock price
|
||||
K=185, # Strike price
|
||||
T=30/365, # Time to expiration (years)
|
||||
r=0.053, # Risk-free rate (5.3%)
|
||||
sigma=0.25, # Volatility (25%)
|
||||
q=0.01 # Dividend yield (1%)
|
||||
)
|
||||
|
||||
# Get call option price
|
||||
call_price = pricer.call_price()
|
||||
print(f"Call Price: ${call_price:.2f}")
|
||||
|
||||
# Get all Greeks for call
|
||||
call_greeks = pricer.get_all_greeks('call')
|
||||
print(f"Delta: {call_greeks['delta']:.4f}")
|
||||
print(f"Gamma: {call_greeks['gamma']:.4f}")
|
||||
print(f"Theta: ${call_greeks['theta']:.2f}/day")
|
||||
print(f"Vega: ${call_greeks['vega']:.2f} per 1%")
|
||||
```
|
||||
|
||||
### Calculate Historical Volatility
|
||||
|
||||
```python
|
||||
from scripts.black_scholes import (
|
||||
calculate_historical_volatility,
|
||||
fetch_historical_prices_for_hv
|
||||
)
|
||||
|
||||
# Fetch prices from FMP
|
||||
api_key = "your_key"
|
||||
prices = fetch_historical_prices_for_hv("AAPL", api_key, days=90)
|
||||
|
||||
# Calculate 30-day HV
|
||||
hv = calculate_historical_volatility(prices, window=30)
|
||||
print(f"30-Day HV: {hv*100:.2f}%")
|
||||
```
|
||||
|
||||
## Understanding the Metrics
|
||||
|
||||
### Option Price Components
|
||||
|
||||
**Intrinsic Value:**
|
||||
- Call: max(0, Stock Price - Strike Price)
|
||||
- Put: max(0, Strike Price - Stock Price)
|
||||
|
||||
**Time Value:**
|
||||
- Option Price - Intrinsic Value
|
||||
- Decays to $0 at expiration
|
||||
|
||||
### The Greeks
|
||||
|
||||
**Delta (Δ)** - Directional Exposure
|
||||
```
|
||||
Range: 0 to 1 (calls), -1 to 0 (puts)
|
||||
Meaning: Change in option price per $1 stock move
|
||||
|
||||
Example: Δ = 0.50
|
||||
→ If stock +$1, option +$0.50
|
||||
→ If stock -$1, option -$0.50
|
||||
```
|
||||
|
||||
**Gamma (Γ)** - Delta Acceleration
|
||||
```
|
||||
Meaning: Change in delta per $1 stock move
|
||||
Peak: ATM options
|
||||
Low: Deep ITM or OTM
|
||||
|
||||
Example: Γ = 0.05, Δ currently = 0.50
|
||||
→ If stock +$1, delta becomes 0.55
|
||||
```
|
||||
|
||||
**Theta (Θ)** - Time Decay
|
||||
```
|
||||
Meaning: Change in option price per day
|
||||
Sign: Usually negative (options lose value over time)
|
||||
Peak: Last 30 days before expiration
|
||||
|
||||
Example: Θ = -$0.15/day
|
||||
→ Tomorrow, option loses $0.15 if nothing else changes
|
||||
```
|
||||
|
||||
**Vega (ν)** - Volatility Sensitivity
|
||||
```
|
||||
Meaning: Change in option price per 1% IV change
|
||||
Sign: Always positive (options gain value when vol increases)
|
||||
|
||||
Example: ν = $0.25 per 1%
|
||||
→ If IV increases from 25% to 26%, option +$0.25
|
||||
```
|
||||
|
||||
**Rho (ρ)** - Interest Rate Sensitivity
|
||||
```
|
||||
Meaning: Change in option price per 1% rate change
|
||||
Sign: Positive for calls, negative for puts
|
||||
Impact: Usually small unless long-dated options
|
||||
|
||||
Example: ρ = $0.10 per 1%
|
||||
→ If interest rate increases 1%, option +$0.10
|
||||
```
|
||||
|
||||
### Volatility: HV vs IV
|
||||
|
||||
**Historical Volatility (HV):**
|
||||
- Calculated from past price movements
|
||||
- Objective, based on actual data
|
||||
- Available free (from price data)
|
||||
|
||||
**Implied Volatility (IV):**
|
||||
- Derived from option market prices
|
||||
- Subjective, based on supply/demand
|
||||
- Requires real-time options data (or user input)
|
||||
|
||||
**Comparison:**
|
||||
```
|
||||
IV > HV: Options expensive → Consider selling premium
|
||||
IV < HV: Options cheap → Consider buying options
|
||||
IV = HV: Fairly priced → Any strategy works
|
||||
```
|
||||
|
||||
## Common Workflows
|
||||
|
||||
### 1. Analyze a Strategy
|
||||
|
||||
```python
|
||||
from scripts.black_scholes import OptionPricer
|
||||
|
||||
# Stock: AAPL @ $180
|
||||
# Strategy: Bull Call Spread $180/$185 (30 DTE)
|
||||
|
||||
# Price long call ($180 strike)
|
||||
long_call = OptionPricer(S=180, K=180, T=30/365, r=0.053, sigma=0.25)
|
||||
long_price = long_call.call_price()
|
||||
long_delta = long_call.call_delta()
|
||||
|
||||
# Price short call ($185 strike)
|
||||
short_call = OptionPricer(S=180, K=185, T=30/365, r=0.053, sigma=0.25)
|
||||
short_price = short_call.call_price()
|
||||
short_delta = short_call.call_delta()
|
||||
|
||||
# Strategy metrics
|
||||
net_debit = long_price - short_price
|
||||
max_profit = (185 - 180) - net_debit
|
||||
max_loss = -net_debit
|
||||
position_delta = long_delta - short_delta
|
||||
|
||||
print(f"Bull Call Spread $180/$185")
|
||||
print(f"Net Debit: ${net_debit:.2f}")
|
||||
print(f"Max Profit: ${max_profit:.2f} (at $185+)")
|
||||
print(f"Max Loss: ${max_loss:.2f} (at $180-)")
|
||||
print(f"Position Delta: {position_delta:.4f}")
|
||||
```
|
||||
|
||||
### 2. Compare IV to HV
|
||||
|
||||
```python
|
||||
# Get HV
|
||||
prices = fetch_historical_prices_for_hv("AAPL", api_key, days=90)
|
||||
hv = calculate_historical_volatility(prices, window=30)
|
||||
|
||||
# User provides IV (from broker platform)
|
||||
iv = 0.28 # 28% from ThinkorSwim
|
||||
|
||||
print(f"Historical Volatility: {hv*100:.2f}%")
|
||||
print(f"Implied Volatility: {iv*100:.1f}%")
|
||||
|
||||
if iv > hv * 1.1:
|
||||
print("→ Options expensive (IV > HV) - Consider selling premium")
|
||||
elif iv < hv * 0.9:
|
||||
print("→ Options cheap (IV < HV) - Consider buying options")
|
||||
else:
|
||||
print("→ Fairly priced")
|
||||
```
|
||||
|
||||
### 3. Earnings Strategy
|
||||
|
||||
Check if earnings coming up (use Earnings Calendar skill):
|
||||
```python
|
||||
# If earnings in 7 days:
|
||||
# - IV typically elevated (30-50% higher)
|
||||
# - Consider straddle/strangle (profit from big move)
|
||||
# - Or sell iron condor (profit from IV crush)
|
||||
|
||||
# Example: Long Straddle
|
||||
straddle_cost = call_price + put_price
|
||||
breakeven_up = stock_price + straddle_cost
|
||||
breakeven_down = stock_price - straddle_cost
|
||||
|
||||
print(f"Straddle Cost: ${straddle_cost:.2f}")
|
||||
print(f"Breakevens: ${breakeven_down:.2f} / ${breakeven_up:.2f}")
|
||||
print(f"Need {abs(breakeven_up - stock_price)/stock_price*100:.1f}% move to profit")
|
||||
```
|
||||
|
||||
## Limitations & Best Practices
|
||||
|
||||
### Theoretical vs Market Prices
|
||||
|
||||
**Black-Scholes Assumptions:**
|
||||
- European options (can't exercise early)
|
||||
- Constant volatility (changes in reality)
|
||||
- No transaction costs
|
||||
- Continuous trading
|
||||
|
||||
**Real World Differences:**
|
||||
- American options (most stocks) can exercise early
|
||||
- Bid-ask spread: Actual cost higher than theoretical mid
|
||||
- Commissions and slippage
|
||||
- Liquidity: Wide markets on illiquid options
|
||||
|
||||
### Best Practices
|
||||
|
||||
**1. Use for Education & Planning:**
|
||||
- Learn how strategies work
|
||||
- Compare different approaches
|
||||
- Understand risk/reward before trading
|
||||
|
||||
**2. Verify Before Trading:**
|
||||
- Get real quotes from your broker
|
||||
- Check bid-ask spread
|
||||
- Confirm option liquidity (open interest, volume)
|
||||
|
||||
**3. Input Actual IV:**
|
||||
- Theoretical price assumes constant volatility
|
||||
- Use current market IV for accuracy
|
||||
- Check IV percentile (high/low relative to history)
|
||||
|
||||
**4. Account for Dividends:**
|
||||
- Ex-dividend dates affect option prices
|
||||
- Calls lose value, puts gain value on ex-div date
|
||||
- Script supports dividend yield input
|
||||
|
||||
**5. Monitor Greeks:**
|
||||
- Delta: Overall directional exposure
|
||||
- Theta: Daily time decay (seller advantage)
|
||||
- Vega: Volatility risk (watch during earnings)
|
||||
- Gamma: Risk of delta changing (avoid near expiration)
|
||||
|
||||
## Integration with Other Skills
|
||||
|
||||
**Earnings Calendar:**
|
||||
- Fetch earnings dates
|
||||
- Identify IV crush opportunities
|
||||
- Time earnings strategies
|
||||
|
||||
**Technical Analyst:**
|
||||
- Use support/resistance for strike selection
|
||||
- Trend analysis for directional strategies
|
||||
- Breakout potential for straddle timing
|
||||
|
||||
**US Stock Analysis:**
|
||||
- Fundamental analysis for LEAPS
|
||||
- Dividend yield for covered call/put
|
||||
- Earnings quality for earnings plays
|
||||
|
||||
**Bubble Detector:**
|
||||
- High risk → protective puts
|
||||
- Low risk → bullish strategies
|
||||
- Critical risk → avoid long premium
|
||||
|
||||
**Portfolio Manager:**
|
||||
- Track options with stock positions
|
||||
- Aggregate Greeks across portfolio
|
||||
- Options as hedging tool
|
||||
|
||||
## API Usage & Costs
|
||||
|
||||
**Free Tier Sufficient:**
|
||||
- Stock prices: 1 request per symbol
|
||||
- Historical prices (HV): 1 request per symbol
|
||||
- Dividend data: 1 request per symbol
|
||||
|
||||
**Example Analysis Cost:**
|
||||
```
|
||||
Covered Call on AAPL:
|
||||
- Current price: 1 request
|
||||
- HV calculation: 1 request (90 days data)
|
||||
- Dividend yield: 1 request
|
||||
Total: 3 requests
|
||||
|
||||
Daily budget: 250 requests / day
|
||||
→ Can analyze ~80 strategies per day
|
||||
```
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Negative Option Price
|
||||
**Cause:** Invalid inputs (strike vs stock price)
|
||||
**Solution:** Check that inputs make sense
|
||||
|
||||
### Greeks Seem Wrong
|
||||
**Cause:** Using wrong units (annual vs daily)
|
||||
**Solution:** Verify T is in years, theta is per day
|
||||
|
||||
### HV Very Different from IV
|
||||
**Normal:** IV reflects future expectations, HV is past
|
||||
**Action:** Use IV from broker for more accuracy
|
||||
|
||||
### Option Price Too High/Low
|
||||
**Cause:** Volatility input incorrect
|
||||
**Solution:** Verify sigma is annual (e.g., 0.25 for 25%)
|
||||
|
||||
## Resources
|
||||
|
||||
### Documentation
|
||||
- `SKILL.md` - Complete workflow and strategies
|
||||
- `references/strategies_guide.md` - All strategies explained (TBD)
|
||||
- `references/greeks_explained.md` - Greeks deep dive (TBD)
|
||||
|
||||
### External Resources
|
||||
- Options Playbook: https://www.optionsplaybook.com/
|
||||
- CBOE Education: https://www.cboe.com/education/
|
||||
- Black-Scholes Calculator: https://www.option-price.com/
|
||||
|
||||
### Get Real IV
|
||||
- ThinkorSwim (TD Ameritrade): Free
|
||||
- TastyTrade: Free
|
||||
- Barchart: https://www.barchart.com/options
|
||||
- CBOE: http://www.cboe.com/delayedquote/
|
||||
|
||||
## Future Enhancements
|
||||
|
||||
**Planned:**
|
||||
- Strategy simulation script (complete P/L analysis)
|
||||
- P/L diagram generator (ASCII art)
|
||||
- Earnings strategy advisor (integrated with Earnings Calendar)
|
||||
- Complete strategy reference guides
|
||||
|
||||
**Contributions Welcome:**
|
||||
- Additional strategies
|
||||
- Improved volatility models
|
||||
- Better visualization tools
|
||||
|
||||
## License
|
||||
|
||||
Educational use. Trade at your own risk. Options involve significant risk and are not suitable for all investors.
|
||||
|
||||
---
|
||||
|
||||
**Version:** 1.0
|
||||
**Last Updated:** 2025-11-08
|
||||
**Dependencies:** Python 3.8+, numpy, scipy, requests
|
||||
**API:** FMP API (Free tier sufficient)
|
||||
**Model:** Black-Scholes (European options pricing)
|
||||
959
skills/options-strategy-advisor/SKILL.md
Normal file
959
skills/options-strategy-advisor/SKILL.md
Normal file
@@ -0,0 +1,959 @@
|
||||
---
|
||||
name: options-strategy-advisor
|
||||
description: Options trading strategy analysis and simulation tool. Provides theoretical pricing using Black-Scholes model, Greeks calculation, strategy P/L simulation, and risk management guidance. Use when user requests options strategy analysis, covered calls, protective puts, spreads, iron condors, earnings plays, or options risk management. Includes volatility analysis, position sizing, and earnings-based strategy recommendations. Educational focus with practical trade simulation.
|
||||
---
|
||||
|
||||
# Options Strategy Advisor
|
||||
|
||||
## Overview
|
||||
|
||||
This skill provides comprehensive options strategy analysis and education using theoretical pricing models. It helps traders understand, analyze, and simulate options strategies without requiring real-time market data subscriptions.
|
||||
|
||||
**Core Capabilities:**
|
||||
- **Black-Scholes Pricing**: Theoretical option prices and Greeks calculation
|
||||
- **Strategy Simulation**: P/L analysis for major options strategies
|
||||
- **Earnings Strategies**: Pre-earnings volatility plays integrated with Earnings Calendar
|
||||
- **Risk Management**: Position sizing, Greeks exposure, max loss/profit analysis
|
||||
- **Educational Focus**: Detailed explanations of strategies and risk metrics
|
||||
|
||||
**Data Sources:**
|
||||
- FMP API: Stock prices, historical volatility, dividends, earnings dates
|
||||
- User Input: Implied volatility (IV), risk-free rate
|
||||
- Theoretical Models: Black-Scholes for pricing and Greeks
|
||||
|
||||
## When to Use This Skill
|
||||
|
||||
Use this skill when:
|
||||
- User asks about options strategies ("What's a covered call?", "How does an iron condor work?")
|
||||
- User wants to simulate strategy P/L ("What's my max profit on a bull call spread?")
|
||||
- User needs Greeks analysis ("What's my delta exposure?")
|
||||
- User asks about earnings strategies ("Should I buy a straddle before earnings?")
|
||||
- User wants to compare strategies ("Covered call vs protective put?")
|
||||
- User needs position sizing guidance ("How many contracts should I trade?")
|
||||
- User asks about volatility ("Is IV high right now?")
|
||||
|
||||
Example requests:
|
||||
- "Analyze a covered call on AAPL"
|
||||
- "What's the P/L on a $100/$105 bull call spread on MSFT?"
|
||||
- "Should I trade a straddle before NVDA earnings?"
|
||||
- "Calculate Greeks for my iron condor position"
|
||||
- "Compare protective put vs covered call for downside protection"
|
||||
|
||||
## Supported Strategies
|
||||
|
||||
### Income Strategies
|
||||
1. **Covered Call** - Own stock, sell call (generate income, cap upside)
|
||||
2. **Cash-Secured Put** - Sell put with cash backing (collect premium, willing to buy stock)
|
||||
3. **Poor Man's Covered Call** - LEAPS call + short near-term call (capital efficient)
|
||||
|
||||
### Protection Strategies
|
||||
4. **Protective Put** - Own stock, buy put (insurance, limited downside)
|
||||
5. **Collar** - Own stock, sell call + buy put (limited upside/downside)
|
||||
|
||||
### Directional Strategies
|
||||
6. **Bull Call Spread** - Buy lower strike call, sell higher strike call (limited risk/reward bullish)
|
||||
7. **Bull Put Spread** - Sell higher strike put, buy lower strike put (credit spread, bullish)
|
||||
8. **Bear Call Spread** - Sell lower strike call, buy higher strike call (credit spread, bearish)
|
||||
9. **Bear Put Spread** - Buy higher strike put, sell lower strike put (limited risk/reward bearish)
|
||||
|
||||
### Volatility Strategies
|
||||
10. **Long Straddle** - Buy ATM call + ATM put (profit from big move either direction)
|
||||
11. **Long Strangle** - Buy OTM call + OTM put (cheaper than straddle, bigger move needed)
|
||||
12. **Short Straddle** - Sell ATM call + ATM put (profit from no movement, unlimited risk)
|
||||
13. **Short Strangle** - Sell OTM call + OTM put (profit from no movement, wider range)
|
||||
|
||||
### Range-Bound Strategies
|
||||
14. **Iron Condor** - Bull put spread + bear call spread (profit from range-bound movement)
|
||||
15. **Iron Butterfly** - Sell ATM straddle, buy OTM strangle (profit from tight range)
|
||||
|
||||
### Advanced Strategies
|
||||
16. **Calendar Spread** - Sell near-term option, buy longer-term option (profit from time decay)
|
||||
17. **Diagonal Spread** - Calendar spread with different strikes (directional + time decay)
|
||||
18. **Ratio Spread** - Unbalanced spread (more contracts on one leg)
|
||||
|
||||
## Analysis Workflow
|
||||
|
||||
### Step 1: Gather Input Data
|
||||
|
||||
**Required from User:**
|
||||
- Ticker symbol
|
||||
- Strategy type
|
||||
- Strike prices
|
||||
- Expiration date(s)
|
||||
- Position size (number of contracts)
|
||||
|
||||
**Optional from User:**
|
||||
- Implied Volatility (IV) - if not provided, use Historical Volatility (HV)
|
||||
- Risk-free rate - default to current 3-month T-bill rate (~5.3% as of 2025)
|
||||
|
||||
**Fetched from FMP API:**
|
||||
- Current stock price
|
||||
- Historical prices (for HV calculation)
|
||||
- Dividend yield
|
||||
- Upcoming earnings date (for earnings strategies)
|
||||
|
||||
**Example User Input:**
|
||||
```
|
||||
Ticker: AAPL
|
||||
Strategy: Bull Call Spread
|
||||
Long Strike: $180
|
||||
Short Strike: $185
|
||||
Expiration: 30 days
|
||||
Contracts: 10
|
||||
IV: 25% (or use HV if not provided)
|
||||
```
|
||||
|
||||
### Step 2: Calculate Historical Volatility (if IV not provided)
|
||||
|
||||
**Objective:** Estimate volatility from historical price movements.
|
||||
|
||||
**Method:**
|
||||
```python
|
||||
# Fetch 90 days of price data
|
||||
prices = get_historical_prices("AAPL", days=90)
|
||||
|
||||
# Calculate daily returns
|
||||
returns = np.log(prices / prices.shift(1))
|
||||
|
||||
# Annualized volatility
|
||||
HV = returns.std() * np.sqrt(252) # 252 trading days
|
||||
```
|
||||
|
||||
**Output:**
|
||||
- Historical Volatility (annualized percentage)
|
||||
- Note to user: "HV = 24.5%, consider using current market IV for more accuracy"
|
||||
|
||||
**User Can Override:**
|
||||
- Provide IV from broker platform (ThinkorSwim, TastyTrade, etc.)
|
||||
- Script accepts `--iv 28.0` parameter
|
||||
|
||||
### Step 3: Price Options Using Black-Scholes
|
||||
|
||||
**Black-Scholes Model:**
|
||||
|
||||
For European-style options:
|
||||
```
|
||||
Call Price = S * N(d1) - K * e^(-r*T) * N(d2)
|
||||
Put Price = K * e^(-r*T) * N(-d2) - S * N(-d1)
|
||||
|
||||
Where:
|
||||
d1 = [ln(S/K) + (r + σ²/2) * T] / (σ * √T)
|
||||
d2 = d1 - σ * √T
|
||||
|
||||
S = Current stock price
|
||||
K = Strike price
|
||||
r = Risk-free rate
|
||||
T = Time to expiration (years)
|
||||
σ = Volatility (IV or HV)
|
||||
N() = Cumulative standard normal distribution
|
||||
```
|
||||
|
||||
**Adjustments:**
|
||||
- Subtract present value of dividends from S for calls
|
||||
- American options: Use approximation or note "European pricing, may undervalue American options"
|
||||
|
||||
**Python Implementation:**
|
||||
```python
|
||||
from scipy.stats import norm
|
||||
import numpy as np
|
||||
|
||||
def black_scholes_call(S, K, T, r, sigma, q=0):
|
||||
"""
|
||||
S: Stock price
|
||||
K: Strike price
|
||||
T: Time to expiration (years)
|
||||
r: Risk-free rate
|
||||
sigma: Volatility
|
||||
q: Dividend yield
|
||||
"""
|
||||
d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
|
||||
d2 = d1 - sigma*np.sqrt(T)
|
||||
|
||||
call_price = S*np.exp(-q*T)*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)
|
||||
return call_price
|
||||
|
||||
def black_scholes_put(S, K, T, r, sigma, q=0):
|
||||
d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
|
||||
d2 = d1 - sigma*np.sqrt(T)
|
||||
|
||||
put_price = K*np.exp(-r*T)*norm.cdf(-d2) - S*np.exp(-q*T)*norm.cdf(-d1)
|
||||
return put_price
|
||||
```
|
||||
|
||||
**Output for Each Option Leg:**
|
||||
- Theoretical price
|
||||
- Note: "Market price may differ due to bid-ask spread and American vs European pricing"
|
||||
|
||||
### Step 4: Calculate Greeks
|
||||
|
||||
**The Greeks** measure option price sensitivity to various factors:
|
||||
|
||||
**Delta (Δ):** Change in option price per $1 change in stock price
|
||||
```python
|
||||
def delta_call(S, K, T, r, sigma, q=0):
|
||||
d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
|
||||
return np.exp(-q*T) * norm.cdf(d1)
|
||||
|
||||
def delta_put(S, K, T, r, sigma, q=0):
|
||||
d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
|
||||
return np.exp(-q*T) * (norm.cdf(d1) - 1)
|
||||
```
|
||||
|
||||
**Gamma (Γ):** Change in delta per $1 change in stock price
|
||||
```python
|
||||
def gamma(S, K, T, r, sigma, q=0):
|
||||
d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
|
||||
return np.exp(-q*T) * norm.pdf(d1) / (S * sigma * np.sqrt(T))
|
||||
```
|
||||
|
||||
**Theta (Θ):** Change in option price per day (time decay)
|
||||
```python
|
||||
def theta_call(S, K, T, r, sigma, q=0):
|
||||
d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
|
||||
d2 = d1 - sigma*np.sqrt(T)
|
||||
|
||||
theta = (-S*norm.pdf(d1)*sigma*np.exp(-q*T)/(2*np.sqrt(T))
|
||||
- r*K*np.exp(-r*T)*norm.cdf(d2)
|
||||
+ q*S*norm.cdf(d1)*np.exp(-q*T))
|
||||
|
||||
return theta / 365 # Per day
|
||||
```
|
||||
|
||||
**Vega (ν):** Change in option price per 1% change in volatility
|
||||
```python
|
||||
def vega(S, K, T, r, sigma, q=0):
|
||||
d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
|
||||
return S * np.exp(-q*T) * norm.pdf(d1) * np.sqrt(T) / 100 # Per 1%
|
||||
```
|
||||
|
||||
**Rho (ρ):** Change in option price per 1% change in interest rate
|
||||
```python
|
||||
def rho_call(S, K, T, r, sigma, q=0):
|
||||
d2 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T)) - sigma*np.sqrt(T)
|
||||
return K * T * np.exp(-r*T) * norm.cdf(d2) / 100 # Per 1%
|
||||
```
|
||||
|
||||
**Position Greeks:**
|
||||
|
||||
For a strategy with multiple legs, sum Greeks across all legs:
|
||||
```python
|
||||
# Example: Bull Call Spread
|
||||
# Long 1x $180 call
|
||||
# Short 1x $185 call
|
||||
|
||||
delta_position = (1 * delta_long) + (-1 * delta_short)
|
||||
gamma_position = (1 * gamma_long) + (-1 * gamma_short)
|
||||
theta_position = (1 * theta_long) + (-1 * theta_short)
|
||||
vega_position = (1 * vega_long) + (-1 * vega_short)
|
||||
```
|
||||
|
||||
**Greeks Interpretation:**
|
||||
|
||||
| Greek | Meaning | Example |
|
||||
|-------|---------|---------|
|
||||
| **Delta** | Directional exposure | Δ = 0.50 → $50 profit if stock +$1 |
|
||||
| **Gamma** | Delta acceleration | Γ = 0.05 → Delta increases by 0.05 if stock +$1 |
|
||||
| **Theta** | Daily time decay | Θ = -$5 → Lose $5/day from time passing |
|
||||
| **Vega** | Volatility sensitivity | ν = $10 → Gain $10 if IV increases 1% |
|
||||
| **Rho** | Interest rate sensitivity | ρ = $2 → Gain $2 if rates increase 1% |
|
||||
|
||||
### Step 5: Simulate Strategy P/L
|
||||
|
||||
**Objective:** Calculate profit/loss at various stock prices at expiration.
|
||||
|
||||
**Method:**
|
||||
|
||||
Generate stock price range (e.g., ±30% from current price):
|
||||
```python
|
||||
current_price = 180
|
||||
price_range = np.linspace(current_price * 0.7, current_price * 1.3, 100)
|
||||
```
|
||||
|
||||
For each price point, calculate P/L:
|
||||
```python
|
||||
def calculate_pnl(strategy, stock_price_at_expiration):
|
||||
pnl = 0
|
||||
|
||||
for leg in strategy.legs:
|
||||
if leg.type == 'call':
|
||||
intrinsic_value = max(0, stock_price_at_expiration - leg.strike)
|
||||
else: # put
|
||||
intrinsic_value = max(0, leg.strike - stock_price_at_expiration)
|
||||
|
||||
if leg.position == 'long':
|
||||
pnl += (intrinsic_value - leg.premium_paid) * 100 # Per contract
|
||||
else: # short
|
||||
pnl += (leg.premium_received - intrinsic_value) * 100
|
||||
|
||||
return pnl * num_contracts
|
||||
```
|
||||
|
||||
**Key Metrics:**
|
||||
- **Max Profit**: Highest possible P/L
|
||||
- **Max Loss**: Worst possible P/L
|
||||
- **Breakeven Point(s)**: Stock price(s) where P/L = 0
|
||||
- **Profit Probability**: Percentage of price range that's profitable (simplified)
|
||||
|
||||
**Example Output:**
|
||||
```
|
||||
Bull Call Spread: $180/$185 on AAPL (30 DTE, 10 contracts)
|
||||
|
||||
Current Price: $180.00
|
||||
Net Debit: $2.50 per spread ($2,500 total)
|
||||
|
||||
Max Profit: $2,500 (at $185+)
|
||||
Max Loss: -$2,500 (at $180-)
|
||||
Breakeven: $182.50
|
||||
Risk/Reward: 1:1
|
||||
|
||||
Probability Profit: ~55% (if stock stays above $182.50)
|
||||
```
|
||||
|
||||
### Step 6: Generate P/L Diagram (ASCII Art)
|
||||
|
||||
**Visual representation of P/L across stock prices:**
|
||||
|
||||
```python
|
||||
def generate_pnl_diagram(price_range, pnl_values, current_price, width=60, height=15):
|
||||
"""Generate ASCII P/L diagram"""
|
||||
|
||||
# Normalize to chart dimensions
|
||||
max_pnl = max(pnl_values)
|
||||
min_pnl = min(pnl_values)
|
||||
|
||||
lines = []
|
||||
lines.append(f"\nP/L Diagram: {strategy_name}")
|
||||
lines.append("-" * width)
|
||||
|
||||
# Y-axis levels
|
||||
levels = np.linspace(max_pnl, min_pnl, height)
|
||||
|
||||
for level in levels:
|
||||
if abs(level) < (max_pnl - min_pnl) * 0.05:
|
||||
label = f" 0 |" # Zero line
|
||||
else:
|
||||
label = f"{level:6.0f} |"
|
||||
|
||||
row = label
|
||||
for i in range(width - len(label)):
|
||||
idx = int(i / (width - len(label)) * len(price_range))
|
||||
pnl = pnl_values[idx]
|
||||
price = price_range[idx]
|
||||
|
||||
# Determine character
|
||||
if abs(pnl - level) < (max_pnl - min_pnl) / height:
|
||||
if pnl > 0:
|
||||
char = '█' # Profit
|
||||
elif pnl < 0:
|
||||
char = '░' # Loss
|
||||
else:
|
||||
char = '─' # Breakeven
|
||||
elif abs(level) < (max_pnl - min_pnl) * 0.05:
|
||||
char = '─' # Zero line
|
||||
elif abs(price - current_price) < (price_range[-1] - price_range[0]) * 0.02:
|
||||
char = '│' # Current price line
|
||||
else:
|
||||
char = ' '
|
||||
|
||||
row += char
|
||||
|
||||
lines.append(row)
|
||||
|
||||
lines.append(" " * 6 + "|" + "-" * (width - 6))
|
||||
lines.append(" " * 6 + f"${price_range[0]:.0f}" + " " * (width - 20) + f"${price_range[-1]:.0f}")
|
||||
lines.append(" " * (width // 2 - 5) + "Stock Price")
|
||||
|
||||
return "\n".join(lines)
|
||||
```
|
||||
|
||||
**Example Output:**
|
||||
```
|
||||
P/L Diagram: Bull Call Spread $180/$185
|
||||
------------------------------------------------------------
|
||||
+2500 | ████████████████████
|
||||
| ██████
|
||||
| ██████
|
||||
| ██████
|
||||
0 | ──────
|
||||
| ░░░░░░
|
||||
|░░░░░░
|
||||
-2500 |░░░░░
|
||||
|____________________________________________________________
|
||||
$126 $180 $234
|
||||
Stock Price
|
||||
|
||||
Legend: █ Profit ░ Loss ── Breakeven │ Current Price
|
||||
```
|
||||
|
||||
### Step 7: Strategy-Specific Analysis
|
||||
|
||||
Provide tailored guidance based on strategy type:
|
||||
|
||||
**Covered Call:**
|
||||
```
|
||||
Income Strategy: Generate premium while capping upside
|
||||
|
||||
Setup:
|
||||
- Own 100 shares of AAPL @ $180
|
||||
- Sell 1x $185 call (30 DTE) for $3.50
|
||||
|
||||
Max Profit: $850 (Stock at $185+ = $5 stock gain + $3.50 premium)
|
||||
Max Loss: Unlimited downside (stock ownership)
|
||||
Breakeven: $176.50 (Cost basis - premium received)
|
||||
|
||||
Greeks:
|
||||
- Delta: -0.30 (reduces stock delta from 1.00 to 0.70)
|
||||
- Theta: +$8/day (time decay benefit)
|
||||
|
||||
Assignment Risk: If AAPL > $185 at expiration, shares called away
|
||||
|
||||
When to Use:
|
||||
- Neutral to slightly bullish
|
||||
- Want income in sideways market
|
||||
- Willing to sell stock at $185
|
||||
|
||||
Exit Plan:
|
||||
- Buy back call if stock rallies strongly (preserve upside)
|
||||
- Let expire if stock stays below $185
|
||||
- Roll to next month if want to keep shares
|
||||
```
|
||||
|
||||
**Protective Put:**
|
||||
```
|
||||
Insurance Strategy: Limit downside while keeping upside
|
||||
|
||||
Setup:
|
||||
- Own 100 shares of AAPL @ $180
|
||||
- Buy 1x $175 put (30 DTE) for $2.00
|
||||
|
||||
Max Profit: Unlimited (stock can rise infinitely)
|
||||
Max Loss: -$7 per share = ($5 stock loss + $2 premium)
|
||||
Breakeven: $182 (Cost basis + premium paid)
|
||||
|
||||
Greeks:
|
||||
- Delta: +0.80 (stock delta 1.00 - put delta 0.20)
|
||||
- Theta: -$6/day (time decay cost)
|
||||
|
||||
Protection: Guaranteed to sell at $175, no matter how far stock falls
|
||||
|
||||
When to Use:
|
||||
- Own stock, worried about short-term drop
|
||||
- Earnings coming up, want protection
|
||||
- Alternative to stop-loss (can't be stopped out)
|
||||
|
||||
Cost: "Insurance premium" - typically 1-3% of stock value
|
||||
|
||||
Exit Plan:
|
||||
- Let expire worthless if stock rises (cost of insurance)
|
||||
- Exercise put if stock falls below $175
|
||||
- Sell put if stock drops but want to keep shares
|
||||
```
|
||||
|
||||
**Iron Condor:**
|
||||
```
|
||||
Range-Bound Strategy: Profit from low volatility
|
||||
|
||||
Setup (example on AAPL @ $180):
|
||||
- Sell $175 put for $1.50
|
||||
- Buy $170 put for $0.50
|
||||
- Sell $185 call for $1.50
|
||||
- Buy $190 call for $0.50
|
||||
|
||||
Net Credit: $2.00 ($200 per iron condor)
|
||||
|
||||
Max Profit: $200 (if stock stays between $175-$185)
|
||||
Max Loss: $300 (if stock moves outside $170-$190)
|
||||
Breakevens: $173 and $187
|
||||
Profit Range: $175 to $185 (58% probability)
|
||||
|
||||
Greeks:
|
||||
- Delta: ~0 (market neutral)
|
||||
- Theta: +$15/day (time decay benefit)
|
||||
- Vega: -$25 (short volatility)
|
||||
|
||||
When to Use:
|
||||
- Expect low volatility, range-bound movement
|
||||
- After big move, think consolidation
|
||||
- High IV environment (sell expensive options)
|
||||
|
||||
Risk: Unlimited if one side tested
|
||||
- Use stop loss at 2x credit received (exit at -$400)
|
||||
|
||||
Adjustments:
|
||||
- If tested on one side, roll that side out in time
|
||||
- Close early at 50% max profit to reduce tail risk
|
||||
```
|
||||
|
||||
### Step 8: Earnings Strategy Analysis
|
||||
|
||||
**Integration with Earnings Calendar:**
|
||||
|
||||
When user asks about earnings strategies, fetch earnings date:
|
||||
```python
|
||||
from earnings_calendar import get_next_earnings_date
|
||||
|
||||
earnings_date = get_next_earnings_date("AAPL")
|
||||
days_to_earnings = (earnings_date - today).days
|
||||
```
|
||||
|
||||
**Pre-Earnings Strategies:**
|
||||
|
||||
**Long Straddle/Strangle:**
|
||||
```
|
||||
Setup (AAPL @ $180, earnings in 7 days):
|
||||
- Buy $180 call for $5.00
|
||||
- Buy $180 put for $4.50
|
||||
- Total Cost: $9.50
|
||||
|
||||
Thesis: Expect big move (>5%) but unsure of direction
|
||||
|
||||
Breakevens: $170.50 and $189.50
|
||||
Profit if: Stock moves >$9.50 in either direction
|
||||
|
||||
Greeks:
|
||||
- Delta: ~0 (neutral)
|
||||
- Vega: +$50 (long volatility)
|
||||
- Theta: -$25/day (time decay hurts)
|
||||
|
||||
IV Crush Risk: ⚠️ CRITICAL
|
||||
- Pre-earnings IV: 40% (elevated)
|
||||
- Post-earnings IV: 25% (typical)
|
||||
- IV drop: -15 points = -$750 loss even if stock doesn't move!
|
||||
|
||||
Analysis:
|
||||
- Implied Move: √(DTE/365) × IV × Stock Price
|
||||
= √(7/365) × 0.40 × 180 = ±$10.50
|
||||
- Breakeven Move Needed: ±$9.50
|
||||
- Probability Profit: ~30-40% (implied move > breakeven move)
|
||||
|
||||
Recommendation:
|
||||
✅ Consider if you expect >10% move (larger than implied)
|
||||
❌ Avoid if expect normal ~5% earnings move (IV crush will hurt)
|
||||
|
||||
Alternative: Buy further OTM strikes to reduce cost
|
||||
- $175/$185 strangle cost $4.00 (need >$8 move, but cheaper)
|
||||
```
|
||||
|
||||
**Short Iron Condor:**
|
||||
```
|
||||
Setup (AAPL @ $180, earnings in 7 days):
|
||||
- Sell $170/$175 put spread for $2.00
|
||||
- Sell $185/$190 call spread for $2.00
|
||||
- Net Credit: $4.00
|
||||
|
||||
Thesis: Expect stock to stay range-bound ($175-$185)
|
||||
|
||||
Profit Zone: $175 to $185
|
||||
Max Profit: $400
|
||||
Max Loss: $100
|
||||
|
||||
IV Crush Benefit: ✅
|
||||
- Short high IV before earnings
|
||||
- IV drops after earnings → profit on vega
|
||||
- Even if stock moves slightly, IV drop helps
|
||||
|
||||
Greeks:
|
||||
- Delta: ~0 (market neutral)
|
||||
- Vega: -$40 (short volatility - good here!)
|
||||
- Theta: +$20/day
|
||||
|
||||
Recommendation:
|
||||
✅ Good if expect normal earnings reaction (<8% move)
|
||||
✅ Benefit from IV crush regardless of direction
|
||||
⚠️ Risk if stock gaps outside range (>10% move)
|
||||
|
||||
Exit Plan:
|
||||
- Close next day if IV crushed (capture profit early)
|
||||
- Use stop loss if one side tested (-2x credit)
|
||||
```
|
||||
|
||||
### Step 9: Risk Management Guidance
|
||||
|
||||
**Position Sizing:**
|
||||
|
||||
```
|
||||
Account Size: $50,000
|
||||
Risk Tolerance: 2% per trade = $1,000 max risk
|
||||
|
||||
Iron Condor Example:
|
||||
- Max loss per spread: $300
|
||||
- Max contracts: $1,000 / $300 = 3 contracts
|
||||
- Actual position: 3 iron condors
|
||||
|
||||
Bull Call Spread Example:
|
||||
- Debit paid: $2.50 per spread
|
||||
- Max contracts: $1,000 / $250 = 4 contracts
|
||||
- Actual position: 4 spreads
|
||||
```
|
||||
|
||||
**Portfolio Greeks Management:**
|
||||
|
||||
```
|
||||
Portfolio Guidelines:
|
||||
- Delta: -10 to +10 (mostly neutral)
|
||||
- Theta: Positive preferred (seller advantage)
|
||||
- Vega: Monitor if >$500 (IV risk)
|
||||
|
||||
Current Portfolio:
|
||||
- Delta: +5 (slightly bullish)
|
||||
- Theta: +$150/day (collecting $150 daily)
|
||||
- Vega: -$300 (short volatility)
|
||||
|
||||
Interpretation:
|
||||
✅ Neutral delta (safe)
|
||||
✅ Positive theta (time working for you)
|
||||
⚠️ Short vega: If IV spikes, lose $300 per 1% IV increase
|
||||
→ Reduce short premium positions if VIX rising
|
||||
```
|
||||
|
||||
**Adjustments and Exits:**
|
||||
|
||||
```
|
||||
Exit Rules by Strategy:
|
||||
|
||||
Covered Call:
|
||||
- Profit: 50-75% of max profit
|
||||
- Loss: Stock drops >5%, buy back call to preserve upside
|
||||
- Time: 7-10 DTE, roll to avoid assignment
|
||||
|
||||
Spreads:
|
||||
- Profit: 50% of max profit (close early, reduce tail risk)
|
||||
- Loss: 2x debit paid (cut losses early)
|
||||
- Time: 21 DTE, close or roll (avoid gamma risk)
|
||||
|
||||
Iron Condor:
|
||||
- Profit: 50% of credit (close early common)
|
||||
- Loss: One side tested, 2x credit lost
|
||||
- Adjustment: Roll tested side out in time
|
||||
|
||||
Straddle/Strangle:
|
||||
- Profit: Stock moved >breakeven, close immediately
|
||||
- Loss: Theta eating position, stock not moving
|
||||
- Time: Day after earnings (if earnings play)
|
||||
```
|
||||
|
||||
## Output Format
|
||||
|
||||
**Strategy Analysis Report Template:**
|
||||
|
||||
```markdown
|
||||
# Options Strategy Analysis: [Strategy Name]
|
||||
|
||||
**Symbol:** [TICKER]
|
||||
**Strategy:** [Strategy Type]
|
||||
**Expiration:** [Date] ([DTE] days)
|
||||
**Contracts:** [Number]
|
||||
|
||||
---
|
||||
|
||||
## Strategy Setup
|
||||
|
||||
### Leg Details
|
||||
| Leg | Type | Strike | Price | Position | Quantity |
|
||||
|-----|------|--------|-------|----------|----------|
|
||||
| 1 | Call | $180 | $5.00 | Long | 1 |
|
||||
| 2 | Call | $185 | $2.50 | Short | 1 |
|
||||
|
||||
**Net Debit/Credit:** $2.50 debit ($250 total for 1 spread)
|
||||
|
||||
---
|
||||
|
||||
## Profit/Loss Analysis
|
||||
|
||||
**Max Profit:** $250 (at $185+)
|
||||
**Max Loss:** -$250 (at $180-)
|
||||
**Breakeven:** $182.50
|
||||
**Risk/Reward Ratio:** 1:1
|
||||
|
||||
**Probability Analysis:**
|
||||
- Probability of Profit: ~55% (stock above $182.50)
|
||||
- Expected Value: $25 (simplified)
|
||||
|
||||
---
|
||||
|
||||
## P/L Diagram
|
||||
|
||||
[ASCII art diagram here]
|
||||
|
||||
---
|
||||
|
||||
## Greeks Analysis
|
||||
|
||||
### Position Greeks (1 spread)
|
||||
- **Delta:** +0.20 (gains $20 if stock +$1)
|
||||
- **Gamma:** +0.03 (delta increases by 0.03 if stock +$1)
|
||||
- **Theta:** -$5/day (loses $5 per day from time decay)
|
||||
- **Vega:** +$8 (gains $8 if IV increases 1%)
|
||||
|
||||
### Interpretation
|
||||
- **Directional Bias:** Slightly bullish (positive delta)
|
||||
- **Time Decay:** Working against you (negative theta)
|
||||
- **Volatility:** Benefits from IV increase (positive vega)
|
||||
|
||||
---
|
||||
|
||||
## Risk Assessment
|
||||
|
||||
### Maximum Risk
|
||||
**Scenario:** Stock falls below $180
|
||||
**Max Loss:** -$250 (100% of premium paid)
|
||||
**% of Account:** 0.5% (if $50k account)
|
||||
|
||||
### Assignment Risk
|
||||
**Early Assignment:** Low (calls have time value)
|
||||
**At Expiration:** Manage positions if in-the-money
|
||||
|
||||
---
|
||||
|
||||
## Trade Management
|
||||
|
||||
### Entry
|
||||
✅ Enter if: [Conditions]
|
||||
- Stock price $178-$182
|
||||
- IV below 30%
|
||||
- >21 DTE
|
||||
|
||||
### Profit Taking
|
||||
- **Target 1:** 50% profit ($125) - Close half
|
||||
- **Target 2:** 75% profit ($187.50) - Close all
|
||||
|
||||
### Stop Loss
|
||||
- **Trigger:** Stock falls below $177 (-$150 loss)
|
||||
- **Action:** Close position immediately
|
||||
|
||||
### Adjustments
|
||||
- If stock rallies to $184, consider rolling short call higher
|
||||
- If stock drops to $179, add second spread at $175/$180
|
||||
|
||||
---
|
||||
|
||||
## Suitability
|
||||
|
||||
### When to Use This Strategy
|
||||
✅ Moderately bullish on AAPL
|
||||
✅ Expect upside to $185-$190
|
||||
✅ Want defined risk
|
||||
✅ 21-45 DTE timeframe
|
||||
|
||||
### When to Avoid
|
||||
❌ Very bullish (buy stock or long call instead)
|
||||
❌ High IV environment (wait for IV to drop)
|
||||
❌ Earnings in <7 days (IV crush risk)
|
||||
|
||||
---
|
||||
|
||||
## Alternatives Comparison
|
||||
|
||||
| Strategy | Max Profit | Max Loss | Complexity | When Better |
|
||||
|----------|-----------|----------|------------|-------------|
|
||||
| Bull Call Spread | $250 | -$250 | Medium | Moderately bullish |
|
||||
| Long Call | Unlimited | -$500 | Low | Very bullish |
|
||||
| Covered Call | $850 | Unlimited | Medium | Own stock already |
|
||||
| Bull Put Spread | $300 | -$200 | Medium | Want credit spread |
|
||||
|
||||
**Recommendation:** Bull call spread is good balance of risk/reward for moderate bullish thesis.
|
||||
|
||||
---
|
||||
|
||||
*Disclaimer: This is theoretical analysis using Black-Scholes pricing. Actual market prices may differ. Trade at your own risk. Options are complex instruments with significant loss potential.*
|
||||
```
|
||||
|
||||
**File Naming Convention:**
|
||||
```
|
||||
options_analysis_[TICKER]_[STRATEGY]_[DATE].md
|
||||
```
|
||||
|
||||
Example: `options_analysis_AAPL_BullCallSpread_2025-11-08.md`
|
||||
|
||||
## Key Principles
|
||||
|
||||
### Theoretical Pricing Limitations
|
||||
|
||||
**What Users Should Know:**
|
||||
1. **Black-Scholes Assumptions:**
|
||||
- European-style options (can't exercise early)
|
||||
- Constant volatility (IV changes in reality)
|
||||
- No transaction costs
|
||||
- Continuous trading
|
||||
|
||||
2. **Real vs Theoretical:**
|
||||
- Bid-ask spread: Actual cost higher than theoretical
|
||||
- American options: Can be exercised early (especially ITM puts)
|
||||
- Liquidity: Wide markets on illiquid options
|
||||
- Dividends: Ex-dividend dates affect pricing
|
||||
|
||||
3. **Best Practices:**
|
||||
- Use as educational tool and comparative analysis
|
||||
- Get real quotes from broker before trading
|
||||
- Understand theoretical price ≈ mid-market price
|
||||
- Account for commissions and slippage
|
||||
|
||||
### Volatility Guidance
|
||||
|
||||
**Historical vs Implied Volatility:**
|
||||
|
||||
```
|
||||
Historical Volatility (HV): What happened
|
||||
- Calculated from past price movements
|
||||
- Objective, based on data
|
||||
- Available for free (FMP API)
|
||||
|
||||
Implied Volatility (IV): What market expects
|
||||
- Derived from option prices
|
||||
- Subjective, based on supply/demand
|
||||
- Requires live options data (user provides)
|
||||
|
||||
Comparison:
|
||||
- IV > HV: Options expensive (consider selling)
|
||||
- IV < HV: Options cheap (consider buying)
|
||||
- IV = HV: Fairly priced
|
||||
```
|
||||
|
||||
**IV Percentile:**
|
||||
|
||||
User provides current IV, we calculate percentile:
|
||||
```python
|
||||
# Fetch 1-year HV data
|
||||
historical_hvs = calculate_hv_series(prices_1yr, window=30)
|
||||
|
||||
# Calculate IV percentile
|
||||
iv_percentile = percentileofscore(historical_hvs, current_iv)
|
||||
|
||||
if iv_percentile > 75:
|
||||
guidance = "High IV - consider selling premium (credit spreads, iron condors)"
|
||||
elif iv_percentile < 25:
|
||||
guidance = "Low IV - consider buying options (long calls/puts, debit spreads)"
|
||||
else:
|
||||
guidance = "Normal IV - any strategy appropriate"
|
||||
```
|
||||
|
||||
## Integration with Other Skills
|
||||
|
||||
**Earnings Calendar:**
|
||||
- Fetch earnings dates automatically
|
||||
- Suggest earnings-specific strategies
|
||||
- Calculate days to earnings (DTE critical for IV)
|
||||
- Warn about IV crush risk
|
||||
|
||||
**Technical Analyst:**
|
||||
- Use support/resistance for strike selection
|
||||
- Trend analysis for directional strategies
|
||||
- Breakout potential for straddle/strangle timing
|
||||
|
||||
**US Stock Analysis:**
|
||||
- Fundamental analysis for longer-term strategies (LEAPS)
|
||||
- Dividend yield for covered call/put analysis
|
||||
- Earnings quality for earnings plays
|
||||
|
||||
**Bubble Detector:**
|
||||
- High bubble risk → focus on protective puts
|
||||
- Low risk → bullish strategies
|
||||
- Critical risk → avoid long premium (theta hurts)
|
||||
|
||||
**Portfolio Manager:**
|
||||
- Track options positions alongside stock positions
|
||||
- Aggregate Greeks across portfolio
|
||||
- Options as hedging tool for stock positions
|
||||
|
||||
## Important Notes
|
||||
|
||||
- **All analysis in English**
|
||||
- **Educational focus**: Strategies explained clearly
|
||||
- **Theoretical pricing**: Black-Scholes approximation
|
||||
- **User IV input**: Optional, defaults to HV
|
||||
- **No real-time data required**: FMP Free tier sufficient
|
||||
- **Dependencies**: Python 3.8+, numpy, scipy, pandas
|
||||
|
||||
## Common Use Cases
|
||||
|
||||
**Use Case 1: Learn Strategy**
|
||||
```
|
||||
User: "Explain a covered call"
|
||||
|
||||
Workflow:
|
||||
1. Load strategy reference (references/strategies_guide.md)
|
||||
2. Explain concept, risk/reward, when to use
|
||||
3. Simulate example on AAPL
|
||||
4. Show P/L diagram
|
||||
5. Compare to alternatives
|
||||
```
|
||||
|
||||
**Use Case 2: Analyze Specific Trade**
|
||||
```
|
||||
User: "Analyze $180/$185 bull call spread on AAPL, 30 days"
|
||||
|
||||
Workflow:
|
||||
1. Fetch AAPL price from FMP
|
||||
2. Calculate HV or ask user for IV
|
||||
3. Price both options (Black-Scholes)
|
||||
4. Calculate Greeks
|
||||
5. Simulate P/L
|
||||
6. Generate analysis report
|
||||
```
|
||||
|
||||
**Use Case 3: Earnings Strategy**
|
||||
```
|
||||
User: "Should I trade options before NVDA earnings?"
|
||||
|
||||
Workflow:
|
||||
1. Fetch NVDA earnings date (Earnings Calendar)
|
||||
2. Calculate days to earnings
|
||||
3. Estimate IV percentile (if user provides IV)
|
||||
4. Suggest straddle/strangle vs iron condor
|
||||
5. Warn about IV crush
|
||||
6. Simulate both strategies
|
||||
```
|
||||
|
||||
**Use Case 4: Portfolio Greeks Check**
|
||||
```
|
||||
User: "What are my total portfolio Greeks?"
|
||||
|
||||
Workflow:
|
||||
1. User provides current positions
|
||||
2. Calculate Greeks for each position
|
||||
3. Sum Greeks across portfolio
|
||||
4. Assess overall exposure
|
||||
5. Suggest adjustments if needed
|
||||
```
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
**Problem: IV not available**
|
||||
- Solution: Use HV as proxy, note to user
|
||||
- Ask user to provide IV from broker platform
|
||||
|
||||
**Problem: Negative option price**
|
||||
- Solution: Check inputs (strike vs stock price)
|
||||
- Deep ITM options may have numerical issues
|
||||
|
||||
**Problem: Greeks seem wrong**
|
||||
- Solution: Verify inputs (T, sigma, r)
|
||||
- Check if using annual vs daily values
|
||||
|
||||
**Problem: Strategy too complex**
|
||||
- Solution: Break into legs, analyze separately
|
||||
- Refer to references for strategy details
|
||||
|
||||
## Resources
|
||||
|
||||
**References:**
|
||||
- `references/strategies_guide.md` - All 17+ strategies explained
|
||||
- `references/greeks_explained.md` - Greeks deep dive
|
||||
- `references/volatility_guide.md` - HV vs IV, when to trade
|
||||
|
||||
**Scripts:**
|
||||
- `scripts/black_scholes.py` - Pricing engine and Greeks
|
||||
- `scripts/strategy_analyzer.py` - Strategy simulation
|
||||
- `scripts/earnings_strategy.py` - Earnings-specific analysis
|
||||
|
||||
**External Resources:**
|
||||
- Options Playbook: https://www.optionsplaybook.com/
|
||||
- CBOE Education: https://www.cboe.com/education/
|
||||
- Black-Scholes Calculator: Various online tools for verification
|
||||
|
||||
---
|
||||
|
||||
**Version**: 1.0
|
||||
**Last Updated**: 2025-11-08
|
||||
**Dependencies**: Python 3.8+, numpy, scipy, pandas, requests
|
||||
**API**: FMP API (Free tier sufficient)
|
||||
495
skills/options-strategy-advisor/scripts/black_scholes.py
Normal file
495
skills/options-strategy-advisor/scripts/black_scholes.py
Normal file
@@ -0,0 +1,495 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Black-Scholes Options Pricing Engine
|
||||
|
||||
Calculates theoretical option prices and Greeks using Black-Scholes model.
|
||||
|
||||
Features:
|
||||
- European call and put pricing
|
||||
- All Greeks (Delta, Gamma, Theta, Vega, Rho)
|
||||
- Historical volatility calculation from price data
|
||||
- Dividend adjustment support
|
||||
|
||||
Usage:
|
||||
from black_scholes import OptionPricer
|
||||
|
||||
pricer = OptionPricer(
|
||||
S=180, # Stock price
|
||||
K=185, # Strike price
|
||||
T=30/365, # Time to expiration (years)
|
||||
r=0.053, # Risk-free rate
|
||||
sigma=0.25, # Volatility
|
||||
q=0.01 # Dividend yield
|
||||
)
|
||||
|
||||
call_price = pricer.call_price()
|
||||
delta = pricer.call_delta()
|
||||
|
||||
Author: Claude Trading Skills
|
||||
Version: 1.0
|
||||
"""
|
||||
|
||||
import numpy as np
|
||||
from scipy.stats import norm
|
||||
import requests
|
||||
import os
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
|
||||
class OptionPricer:
|
||||
"""Black-Scholes option pricer with Greeks calculation"""
|
||||
|
||||
def __init__(self, S, K, T, r, sigma, q=0):
|
||||
"""
|
||||
Initialize pricer with option parameters
|
||||
|
||||
Parameters:
|
||||
-----------
|
||||
S : float
|
||||
Current stock price
|
||||
K : float
|
||||
Strike price
|
||||
T : float
|
||||
Time to expiration in years (e.g., 30/365 for 30 days)
|
||||
r : float
|
||||
Risk-free interest rate (annual, e.g., 0.053 for 5.3%)
|
||||
sigma : float
|
||||
Volatility (annual, e.g., 0.25 for 25%)
|
||||
q : float, optional
|
||||
Continuous dividend yield (annual, default 0)
|
||||
"""
|
||||
self.S = S
|
||||
self.K = K
|
||||
self.T = T
|
||||
self.r = r
|
||||
self.sigma = sigma
|
||||
self.q = q
|
||||
|
||||
# Validate inputs
|
||||
if S <= 0:
|
||||
raise ValueError("Stock price must be positive")
|
||||
if K <= 0:
|
||||
raise ValueError("Strike price must be positive")
|
||||
if T <= 0:
|
||||
raise ValueError("Time to expiration must be positive")
|
||||
if sigma <= 0:
|
||||
raise ValueError("Volatility must be positive")
|
||||
|
||||
def _d1(self):
|
||||
"""Calculate d1 parameter"""
|
||||
numerator = np.log(self.S / self.K) + (self.r - self.q + 0.5 * self.sigma**2) * self.T
|
||||
denominator = self.sigma * np.sqrt(self.T)
|
||||
return numerator / denominator
|
||||
|
||||
def _d2(self):
|
||||
"""Calculate d2 parameter"""
|
||||
return self._d1() - self.sigma * np.sqrt(self.T)
|
||||
|
||||
# =========================================================================
|
||||
# Option Pricing
|
||||
# =========================================================================
|
||||
|
||||
def call_price(self):
|
||||
"""Calculate European call option price"""
|
||||
d1 = self._d1()
|
||||
d2 = self._d2()
|
||||
|
||||
price = (self.S * np.exp(-self.q * self.T) * norm.cdf(d1) -
|
||||
self.K * np.exp(-self.r * self.T) * norm.cdf(d2))
|
||||
|
||||
return max(0, price) # Price cannot be negative
|
||||
|
||||
def put_price(self):
|
||||
"""Calculate European put option price"""
|
||||
d1 = self._d1()
|
||||
d2 = self._d2()
|
||||
|
||||
price = (self.K * np.exp(-self.r * self.T) * norm.cdf(-d2) -
|
||||
self.S * np.exp(-self.q * self.T) * norm.cdf(-d1))
|
||||
|
||||
return max(0, price)
|
||||
|
||||
# =========================================================================
|
||||
# Greeks - First Order
|
||||
# =========================================================================
|
||||
|
||||
def call_delta(self):
|
||||
"""
|
||||
Calculate call delta
|
||||
|
||||
Delta: Change in option price per $1 change in stock price
|
||||
Range: 0 to 1 for calls
|
||||
"""
|
||||
d1 = self._d1()
|
||||
return np.exp(-self.q * self.T) * norm.cdf(d1)
|
||||
|
||||
def put_delta(self):
|
||||
"""
|
||||
Calculate put delta
|
||||
|
||||
Delta: Change in option price per $1 change in stock price
|
||||
Range: -1 to 0 for puts
|
||||
"""
|
||||
d1 = self._d1()
|
||||
return np.exp(-self.q * self.T) * (norm.cdf(d1) - 1)
|
||||
|
||||
def vega(self):
|
||||
"""
|
||||
Calculate vega (same for calls and puts)
|
||||
|
||||
Vega: Change in option price per 1% change in volatility
|
||||
Always positive (options gain value when volatility increases)
|
||||
"""
|
||||
d1 = self._d1()
|
||||
vega = self.S * np.exp(-self.q * self.T) * norm.pdf(d1) * np.sqrt(self.T)
|
||||
return vega / 100 # Per 1% change in volatility
|
||||
|
||||
def call_theta(self):
|
||||
"""
|
||||
Calculate call theta
|
||||
|
||||
Theta: Change in option price per day (time decay)
|
||||
Usually negative (options lose value as time passes)
|
||||
"""
|
||||
d1 = self._d1()
|
||||
d2 = self._d2()
|
||||
|
||||
term1 = -self.S * norm.pdf(d1) * self.sigma * np.exp(-self.q * self.T) / (2 * np.sqrt(self.T))
|
||||
term2 = -self.r * self.K * np.exp(-self.r * self.T) * norm.cdf(d2)
|
||||
term3 = self.q * self.S * norm.cdf(d1) * np.exp(-self.q * self.T)
|
||||
|
||||
theta_annual = term1 + term2 + term3
|
||||
return theta_annual / 365 # Convert to per-day
|
||||
|
||||
def put_theta(self):
|
||||
"""Calculate put theta"""
|
||||
d1 = self._d1()
|
||||
d2 = self._d2()
|
||||
|
||||
term1 = -self.S * norm.pdf(d1) * self.sigma * np.exp(-self.q * self.T) / (2 * np.sqrt(self.T))
|
||||
term2 = self.r * self.K * np.exp(-self.r * self.T) * norm.cdf(-d2)
|
||||
term3 = -self.q * self.S * norm.cdf(-d1) * np.exp(-self.q * self.T)
|
||||
|
||||
theta_annual = term1 + term2 + term3
|
||||
return theta_annual / 365
|
||||
|
||||
def call_rho(self):
|
||||
"""
|
||||
Calculate call rho
|
||||
|
||||
Rho: Change in option price per 1% change in interest rate
|
||||
Positive for calls (calls gain value when rates increase)
|
||||
"""
|
||||
d2 = self._d2()
|
||||
rho = self.K * self.T * np.exp(-self.r * self.T) * norm.cdf(d2)
|
||||
return rho / 100 # Per 1% change
|
||||
|
||||
def put_rho(self):
|
||||
"""
|
||||
Calculate put rho
|
||||
|
||||
Rho: Change in option price per 1% change in interest rate
|
||||
Negative for puts (puts lose value when rates increase)
|
||||
"""
|
||||
d2 = self._d2()
|
||||
rho = -self.K * self.T * np.exp(-self.r * self.T) * norm.cdf(-d2)
|
||||
return rho / 100
|
||||
|
||||
# =========================================================================
|
||||
# Greeks - Second Order
|
||||
# =========================================================================
|
||||
|
||||
def gamma(self):
|
||||
"""
|
||||
Calculate gamma (same for calls and puts)
|
||||
|
||||
Gamma: Change in delta per $1 change in stock price
|
||||
Shows how fast delta changes
|
||||
Highest for ATM options, lower for OTM and ITM
|
||||
"""
|
||||
d1 = self._d1()
|
||||
gamma = (np.exp(-self.q * self.T) * norm.pdf(d1)) / (self.S * self.sigma * np.sqrt(self.T))
|
||||
return gamma
|
||||
|
||||
# =========================================================================
|
||||
# Utility Methods
|
||||
# =========================================================================
|
||||
|
||||
def intrinsic_value(self, option_type='call'):
|
||||
"""Calculate intrinsic value"""
|
||||
if option_type.lower() == 'call':
|
||||
return max(0, self.S - self.K)
|
||||
else: # put
|
||||
return max(0, self.K - self.S)
|
||||
|
||||
def time_value(self, option_type='call'):
|
||||
"""Calculate time value (extrinsic value)"""
|
||||
if option_type.lower() == 'call':
|
||||
price = self.call_price()
|
||||
else:
|
||||
price = self.put_price()
|
||||
|
||||
intrinsic = self.intrinsic_value(option_type)
|
||||
return price - intrinsic
|
||||
|
||||
def moneyness(self):
|
||||
"""
|
||||
Determine moneyness
|
||||
|
||||
Returns: 'ITM', 'ATM', or 'OTM'
|
||||
"""
|
||||
ratio = self.S / self.K
|
||||
|
||||
if abs(ratio - 1.0) < 0.02: # Within 2%
|
||||
return 'ATM'
|
||||
elif ratio > 1.0:
|
||||
return 'ITM (Call) / OTM (Put)'
|
||||
else:
|
||||
return 'OTM (Call) / ITM (Put)'
|
||||
|
||||
def get_all_greeks(self, option_type='call'):
|
||||
"""
|
||||
Get all Greeks for an option
|
||||
|
||||
Returns: dict with all Greeks
|
||||
"""
|
||||
if option_type.lower() == 'call':
|
||||
return {
|
||||
'price': self.call_price(),
|
||||
'delta': self.call_delta(),
|
||||
'gamma': self.gamma(),
|
||||
'theta': self.call_theta(),
|
||||
'vega': self.vega(),
|
||||
'rho': self.call_rho(),
|
||||
'intrinsic_value': self.intrinsic_value('call'),
|
||||
'time_value': self.time_value('call')
|
||||
}
|
||||
else:
|
||||
return {
|
||||
'price': self.put_price(),
|
||||
'delta': self.put_delta(),
|
||||
'gamma': self.gamma(),
|
||||
'theta': self.put_theta(),
|
||||
'vega': self.vega(),
|
||||
'rho': self.put_rho(),
|
||||
'intrinsic_value': self.intrinsic_value('put'),
|
||||
'time_value': self.time_value('put')
|
||||
}
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# Historical Volatility Calculator
|
||||
# =============================================================================
|
||||
|
||||
def calculate_historical_volatility(prices, window=30):
|
||||
"""
|
||||
Calculate historical volatility from price data
|
||||
|
||||
Parameters:
|
||||
-----------
|
||||
prices : array-like
|
||||
Historical prices (daily)
|
||||
window : int
|
||||
Lookback window in days (default 30)
|
||||
|
||||
Returns:
|
||||
--------
|
||||
float
|
||||
Annualized historical volatility
|
||||
"""
|
||||
if len(prices) < window + 1:
|
||||
raise ValueError(f"Need at least {window + 1} price points")
|
||||
|
||||
# Calculate log returns
|
||||
prices = np.array(prices)
|
||||
log_returns = np.log(prices[1:] / prices[:-1])
|
||||
|
||||
# Use most recent 'window' returns
|
||||
recent_returns = log_returns[-window:]
|
||||
|
||||
# Annualized volatility (252 trading days)
|
||||
volatility = np.std(recent_returns) * np.sqrt(252)
|
||||
|
||||
return volatility
|
||||
|
||||
|
||||
def fetch_historical_prices_for_hv(symbol, api_key, days=90):
|
||||
"""
|
||||
Fetch historical prices from FMP API for HV calculation
|
||||
|
||||
Parameters:
|
||||
-----------
|
||||
symbol : str
|
||||
Stock ticker
|
||||
api_key : str
|
||||
FMP API key
|
||||
days : int
|
||||
Number of days to fetch
|
||||
|
||||
Returns:
|
||||
--------
|
||||
list
|
||||
List of adjusted close prices
|
||||
"""
|
||||
url = f"https://financialmodelingprep.com/api/v3/historical-price-full/{symbol}"
|
||||
params = {'apikey': api_key}
|
||||
|
||||
try:
|
||||
response = requests.get(url, params=params, timeout=30)
|
||||
response.raise_for_status()
|
||||
data = response.json()
|
||||
|
||||
if 'historical' not in data:
|
||||
return None
|
||||
|
||||
# Get most recent 'days' of data
|
||||
historical = data['historical'][:days]
|
||||
historical = historical[::-1] # Reverse to chronological order
|
||||
|
||||
prices = [item['adjClose'] for item in historical]
|
||||
return prices
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error fetching prices for {symbol}: {e}")
|
||||
return None
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# FMP API Integration
|
||||
# =============================================================================
|
||||
|
||||
def get_current_stock_price(symbol, api_key):
|
||||
"""Fetch current stock price from FMP API"""
|
||||
url = f"https://financialmodelingprep.com/api/v3/quote/{symbol}"
|
||||
params = {'apikey': api_key}
|
||||
|
||||
try:
|
||||
response = requests.get(url, params=params, timeout=30)
|
||||
response.raise_for_status()
|
||||
data = response.json()
|
||||
|
||||
if data and len(data) > 0:
|
||||
return data[0]['price']
|
||||
return None
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error fetching current price for {symbol}: {e}")
|
||||
return None
|
||||
|
||||
|
||||
def get_dividend_yield(symbol, api_key):
|
||||
"""Fetch dividend yield from FMP API"""
|
||||
url = f"https://financialmodelingprep.com/api/v3/profile/{symbol}"
|
||||
params = {'apikey': api_key}
|
||||
|
||||
try:
|
||||
response = requests.get(url, params=params, timeout=30)
|
||||
response.raise_for_status()
|
||||
data = response.json()
|
||||
|
||||
if data and len(data) > 0:
|
||||
# Last annual dividend / current price
|
||||
last_div = data[0].get('lastDiv', 0)
|
||||
price = data[0].get('price', 1)
|
||||
div_yield = (last_div / price) if price > 0 else 0
|
||||
return div_yield
|
||||
|
||||
return 0
|
||||
|
||||
except Exception:
|
||||
return 0
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# Example Usage
|
||||
# =============================================================================
|
||||
|
||||
if __name__ == '__main__':
|
||||
print("\n" + "="*70)
|
||||
print("BLACK-SCHOLES OPTIONS PRICER - EXAMPLE")
|
||||
print("="*70)
|
||||
|
||||
# Example parameters
|
||||
stock_price = 180.00
|
||||
strike_price = 185.00
|
||||
days_to_expiration = 30
|
||||
time_to_expiration = days_to_expiration / 365
|
||||
risk_free_rate = 0.053 # 5.3%
|
||||
volatility = 0.25 # 25%
|
||||
dividend_yield = 0.01 # 1%
|
||||
|
||||
print(f"\nInput Parameters:")
|
||||
print(f" Stock Price: ${stock_price:.2f}")
|
||||
print(f" Strike Price: ${strike_price:.2f}")
|
||||
print(f" Days to Expiration: {days_to_expiration}")
|
||||
print(f" Volatility: {volatility*100:.1f}%")
|
||||
print(f" Risk-Free Rate: {risk_free_rate*100:.2f}%")
|
||||
print(f" Dividend Yield: {dividend_yield*100:.1f}%")
|
||||
|
||||
# Create pricer
|
||||
pricer = OptionPricer(
|
||||
S=stock_price,
|
||||
K=strike_price,
|
||||
T=time_to_expiration,
|
||||
r=risk_free_rate,
|
||||
sigma=volatility,
|
||||
q=dividend_yield
|
||||
)
|
||||
|
||||
# Call option
|
||||
print(f"\n{'='*70}")
|
||||
print("CALL OPTION")
|
||||
print("="*70)
|
||||
|
||||
call_greeks = pricer.get_all_greeks('call')
|
||||
print(f"Price: ${call_greeks['price']:.2f}")
|
||||
print(f"Intrinsic Value: ${call_greeks['intrinsic_value']:.2f}")
|
||||
print(f"Time Value: ${call_greeks['time_value']:.2f}")
|
||||
print(f"\nGreeks:")
|
||||
print(f" Delta: {call_greeks['delta']:.4f} (${call_greeks['delta']*100:.2f} per $1 move)")
|
||||
print(f" Gamma: {call_greeks['gamma']:.4f} (delta changes by {call_greeks['gamma']:.4f})")
|
||||
print(f" Theta: ${call_greeks['theta']:.2f}/day (loses ${abs(call_greeks['theta']):.2f} per day)")
|
||||
print(f" Vega: ${call_greeks['vega']:.2f} per 1% IV (gains ${call_greeks['vega']:.2f} if IV +1%)")
|
||||
print(f" Rho: ${call_greeks['rho']:.2f} per 1% rate (gains ${call_greeks['rho']:.2f} if rate +1%)")
|
||||
|
||||
# Put option
|
||||
print(f"\n{'='*70}")
|
||||
print("PUT OPTION")
|
||||
print("="*70)
|
||||
|
||||
put_greeks = pricer.get_all_greeks('put')
|
||||
print(f"Price: ${put_greeks['price']:.2f}")
|
||||
print(f"Intrinsic Value: ${put_greeks['intrinsic_value']:.2f}")
|
||||
print(f"Time Value: ${put_greeks['time_value']:.2f}")
|
||||
print(f"\nGreeks:")
|
||||
print(f" Delta: {put_greeks['delta']:.4f} (${put_greeks['delta']*100:.2f} per $1 move)")
|
||||
print(f" Gamma: {put_greeks['gamma']:.4f} (delta changes by {put_greeks['gamma']:.4f})")
|
||||
print(f" Theta: ${put_greeks['theta']:.2f}/day (loses ${abs(put_greeks['theta']):.2f} per day)")
|
||||
print(f" Vega: ${put_greeks['vega']:.2f} per 1% IV (gains ${put_greeks['vega']:.2f} if IV +1%)")
|
||||
print(f" Rho: ${put_greeks['rho']:.2f} per 1% rate (loses ${abs(put_greeks['rho']):.2f} if rate +1%)")
|
||||
|
||||
# Moneyness
|
||||
print(f"\n{'='*70}")
|
||||
print(f"Moneyness: {pricer.moneyness()}")
|
||||
print("="*70 + "\n")
|
||||
|
||||
# Historical Volatility Example
|
||||
print("\nHistorical Volatility Example:")
|
||||
print("-" * 70)
|
||||
|
||||
# Simulate price data
|
||||
np.random.seed(42)
|
||||
simulated_prices = [180 * np.exp(np.sum(np.random.randn(i) * 0.01)) for i in range(90)]
|
||||
|
||||
hv = calculate_historical_volatility(simulated_prices, window=30)
|
||||
print(f"30-Day Historical Volatility: {hv*100:.2f}%")
|
||||
print(f"Implied Volatility (input): {volatility*100:.1f}%")
|
||||
|
||||
if hv < volatility:
|
||||
print(f"→ IV > HV: Options may be expensive (consider selling premium)")
|
||||
elif hv > volatility:
|
||||
print(f"→ IV < HV: Options may be cheap (consider buying)")
|
||||
else:
|
||||
print(f"→ IV ≈ HV: Options fairly priced")
|
||||
|
||||
print("\n" + "="*70 + "\n")
|
||||
Reference in New Issue
Block a user