1307 lines
55 KiB
Python
1307 lines
55 KiB
Python
from typing import Annotated, List, Optional, Union
|
|
from datetime import datetime
|
|
from dateutil.relativedelta import relativedelta
|
|
import yfinance as yf
|
|
import pandas as pd
|
|
import os
|
|
import requests
|
|
from concurrent.futures import ThreadPoolExecutor, as_completed
|
|
from pathlib import Path
|
|
from .stockstats_utils import StockstatsUtils
|
|
|
|
def get_YFin_data_online(
|
|
symbol: Annotated[str, "ticker symbol of the company"],
|
|
start_date: Annotated[str, "Start date in yyyy-mm-dd format"],
|
|
end_date: Annotated[str, "End date in yyyy-mm-dd format"],
|
|
):
|
|
|
|
datetime.strptime(start_date, "%Y-%m-%d")
|
|
datetime.strptime(end_date, "%Y-%m-%d")
|
|
|
|
# Create ticker object
|
|
ticker = yf.Ticker(symbol.upper())
|
|
|
|
# Fetch historical data for the specified date range
|
|
data = ticker.history(start=start_date, end=end_date)
|
|
|
|
# Check if data is empty
|
|
if data.empty:
|
|
return (
|
|
f"No data found for symbol '{symbol}' between {start_date} and {end_date}"
|
|
)
|
|
|
|
# Remove timezone info from index for cleaner output
|
|
if data.index.tz is not None:
|
|
data.index = data.index.tz_localize(None)
|
|
|
|
# Round numerical values to 2 decimal places for cleaner display
|
|
numeric_columns = ["Open", "High", "Low", "Close", "Adj Close"]
|
|
for col in numeric_columns:
|
|
if col in data.columns:
|
|
data[col] = data[col].round(2)
|
|
|
|
# Convert DataFrame to CSV string
|
|
csv_string = data.to_csv()
|
|
|
|
# Add header information
|
|
header = f"# Stock data for {symbol.upper()} from {start_date} to {end_date}\n"
|
|
header += f"# Total records: {len(data)}\n"
|
|
header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
|
|
|
|
return header + csv_string
|
|
|
|
def get_stock_stats_indicators_window(
|
|
symbol: Annotated[str, "ticker symbol of the company"],
|
|
indicator: Annotated[str, "technical indicator to get the analysis and report of"],
|
|
curr_date: Annotated[
|
|
str, "The current trading date you are trading on, YYYY-mm-dd"
|
|
],
|
|
look_back_days: Annotated[int, "how many days to look back"],
|
|
) -> str:
|
|
|
|
best_ind_params = {
|
|
# Moving Averages
|
|
"close_50_sma": (
|
|
"50 SMA: A medium-term trend indicator. "
|
|
"Usage: Identify trend direction and serve as dynamic support/resistance. "
|
|
"Tips: It lags price; combine with faster indicators for timely signals."
|
|
),
|
|
"close_200_sma": (
|
|
"200 SMA: A long-term trend benchmark. "
|
|
"Usage: Confirm overall market trend and identify golden/death cross setups. "
|
|
"Tips: It reacts slowly; best for strategic trend confirmation rather than frequent trading entries."
|
|
),
|
|
"close_10_ema": (
|
|
"10 EMA: A responsive short-term average. "
|
|
"Usage: Capture quick shifts in momentum and potential entry points. "
|
|
"Tips: Prone to noise in choppy markets; use alongside longer averages for filtering false signals."
|
|
),
|
|
# MACD Related
|
|
"macd": (
|
|
"MACD: Computes momentum via differences of EMAs. "
|
|
"Usage: Look for crossovers and divergence as signals of trend changes. "
|
|
"Tips: Confirm with other indicators in low-volatility or sideways markets."
|
|
),
|
|
"macds": (
|
|
"MACD Signal: An EMA smoothing of the MACD line. "
|
|
"Usage: Use crossovers with the MACD line to trigger trades. "
|
|
"Tips: Should be part of a broader strategy to avoid false positives."
|
|
),
|
|
"macdh": (
|
|
"MACD Histogram: Shows the gap between the MACD line and its signal. "
|
|
"Usage: Visualize momentum strength and spot divergence early. "
|
|
"Tips: Can be volatile; complement with additional filters in fast-moving markets."
|
|
),
|
|
# Momentum Indicators
|
|
"rsi": (
|
|
"RSI: Measures momentum to flag overbought/oversold conditions. "
|
|
"Usage: Apply 70/30 thresholds and watch for divergence to signal reversals. "
|
|
"Tips: In strong trends, RSI may remain extreme; always cross-check with trend analysis."
|
|
),
|
|
# Volatility Indicators
|
|
"boll": (
|
|
"Bollinger Middle: A 20 SMA serving as the basis for Bollinger Bands. "
|
|
"Usage: Acts as a dynamic benchmark for price movement. "
|
|
"Tips: Combine with the upper and lower bands to effectively spot breakouts or reversals."
|
|
),
|
|
"boll_ub": (
|
|
"Bollinger Upper Band: Typically 2 standard deviations above the middle line. "
|
|
"Usage: Signals potential overbought conditions and breakout zones. "
|
|
"Tips: Confirm signals with other tools; prices may ride the band in strong trends."
|
|
),
|
|
"boll_lb": (
|
|
"Bollinger Lower Band: Typically 2 standard deviations below the middle line. "
|
|
"Usage: Indicates potential oversold conditions. "
|
|
"Tips: Use additional analysis to avoid false reversal signals."
|
|
),
|
|
"atr": (
|
|
"ATR: Averages true range to measure volatility. "
|
|
"Usage: Set stop-loss levels and adjust position sizes based on current market volatility. "
|
|
"Tips: It's a reactive measure, so use it as part of a broader risk management strategy."
|
|
),
|
|
# Volume-Based Indicators
|
|
"vwma": (
|
|
"VWMA: A moving average weighted by volume. "
|
|
"Usage: Confirm trends by integrating price action with volume data. "
|
|
"Tips: Watch for skewed results from volume spikes; use in combination with other volume analyses."
|
|
),
|
|
"mfi": (
|
|
"MFI: The Money Flow Index is a momentum indicator that uses both price and volume to measure buying and selling pressure. "
|
|
"Usage: Identify overbought (>80) or oversold (<20) conditions and confirm the strength of trends or reversals. "
|
|
"Tips: Use alongside RSI or MACD to confirm signals; divergence between price and MFI can indicate potential reversals."
|
|
),
|
|
}
|
|
|
|
if indicator not in best_ind_params:
|
|
raise ValueError(
|
|
f"Indicator {indicator} is not supported. Please choose from: {list(best_ind_params.keys())}"
|
|
)
|
|
|
|
end_date = curr_date
|
|
curr_date_dt = datetime.strptime(curr_date, "%Y-%m-%d")
|
|
before = curr_date_dt - relativedelta(days=look_back_days)
|
|
|
|
# Optimized: Get stock data once and calculate indicators for all dates
|
|
try:
|
|
indicator_data = _get_stock_stats_bulk(symbol, indicator, curr_date)
|
|
|
|
# Generate the date range we need
|
|
current_dt = curr_date_dt
|
|
date_values = []
|
|
|
|
while current_dt >= before:
|
|
date_str = current_dt.strftime('%Y-%m-%d')
|
|
|
|
# Look up the indicator value for this date
|
|
if date_str in indicator_data:
|
|
indicator_value = indicator_data[date_str]
|
|
else:
|
|
indicator_value = "N/A: Not a trading day (weekend or holiday)"
|
|
|
|
date_values.append((date_str, indicator_value))
|
|
current_dt = current_dt - relativedelta(days=1)
|
|
|
|
# Build the result string
|
|
ind_string = ""
|
|
for date_str, value in date_values:
|
|
ind_string += f"{date_str}: {value}\n"
|
|
|
|
except Exception as e:
|
|
print(f"Error getting bulk stockstats data: {e}")
|
|
# Fallback to original implementation if bulk method fails
|
|
ind_string = ""
|
|
curr_date_dt = datetime.strptime(curr_date, "%Y-%m-%d")
|
|
while curr_date_dt >= before:
|
|
indicator_value = get_stockstats_indicator(
|
|
symbol, indicator, curr_date_dt.strftime("%Y-%m-%d")
|
|
)
|
|
ind_string += f"{curr_date_dt.strftime('%Y-%m-%d')}: {indicator_value}\n"
|
|
curr_date_dt = curr_date_dt - relativedelta(days=1)
|
|
|
|
result_str = (
|
|
f"## {indicator} values from {before.strftime('%Y-%m-%d')} to {end_date}:\n\n"
|
|
+ ind_string
|
|
+ "\n\n"
|
|
+ best_ind_params.get(indicator, "No description available.")
|
|
)
|
|
|
|
return result_str
|
|
|
|
|
|
def _get_stock_stats_bulk(
|
|
symbol: Annotated[str, "ticker symbol of the company"],
|
|
indicator: Annotated[str, "technical indicator to calculate"],
|
|
curr_date: Annotated[str, "current date for reference"]
|
|
) -> dict:
|
|
"""
|
|
Optimized bulk calculation of stock stats indicators.
|
|
Fetches data once and calculates indicator for all available dates.
|
|
Returns dict mapping date strings to indicator values.
|
|
"""
|
|
from .config import get_config
|
|
import pandas as pd
|
|
from stockstats import wrap
|
|
import os
|
|
|
|
config = get_config()
|
|
online = config["data_vendors"]["technical_indicators"] != "local"
|
|
|
|
if not online:
|
|
# Local data path
|
|
try:
|
|
data = pd.read_csv(
|
|
os.path.join(
|
|
config.get("data_cache_dir", "data"),
|
|
f"{symbol}-YFin-data-2015-01-01-2025-03-25.csv",
|
|
)
|
|
)
|
|
df = wrap(data)
|
|
except FileNotFoundError:
|
|
raise Exception("Stockstats fail: Yahoo Finance data not fetched yet!")
|
|
else:
|
|
# Online data fetching with caching
|
|
today_date = pd.Timestamp.today()
|
|
curr_date_dt = pd.to_datetime(curr_date)
|
|
|
|
end_date = today_date
|
|
start_date = today_date - pd.DateOffset(years=2)
|
|
start_date_str = start_date.strftime("%Y-%m-%d")
|
|
end_date_str = end_date.strftime("%Y-%m-%d")
|
|
|
|
os.makedirs(config["data_cache_dir"], exist_ok=True)
|
|
|
|
data_file = os.path.join(
|
|
config["data_cache_dir"],
|
|
f"{symbol}-YFin-data-{start_date_str}-{end_date_str}.csv",
|
|
)
|
|
|
|
if os.path.exists(data_file):
|
|
data = pd.read_csv(data_file)
|
|
data["Date"] = pd.to_datetime(data["Date"])
|
|
else:
|
|
data = yf.download(
|
|
symbol,
|
|
start=start_date_str,
|
|
end=end_date_str,
|
|
multi_level_index=False,
|
|
progress=False,
|
|
auto_adjust=True,
|
|
)
|
|
data = data.reset_index()
|
|
data.to_csv(data_file, index=False)
|
|
|
|
df = wrap(data)
|
|
df["Date"] = df["Date"].dt.strftime("%Y-%m-%d")
|
|
|
|
# Calculate the indicator for all rows at once
|
|
df[indicator] # This triggers stockstats to calculate the indicator
|
|
|
|
# Create a dictionary mapping date strings to indicator values
|
|
result_dict = {}
|
|
for _, row in df.iterrows():
|
|
date_str = row["Date"]
|
|
indicator_value = row[indicator]
|
|
|
|
# Handle NaN/None values
|
|
if pd.isna(indicator_value):
|
|
result_dict[date_str] = "N/A"
|
|
else:
|
|
result_dict[date_str] = str(indicator_value)
|
|
|
|
return result_dict
|
|
|
|
|
|
def get_stockstats_indicator(
|
|
symbol: Annotated[str, "ticker symbol of the company"],
|
|
indicator: Annotated[str, "technical indicator to get the analysis and report of"],
|
|
curr_date: Annotated[
|
|
str, "The current trading date you are trading on, YYYY-mm-dd"
|
|
],
|
|
) -> str:
|
|
|
|
curr_date_dt = datetime.strptime(curr_date, "%Y-%m-%d")
|
|
curr_date = curr_date_dt.strftime("%Y-%m-%d")
|
|
|
|
try:
|
|
indicator_value = StockstatsUtils.get_stock_stats(
|
|
symbol,
|
|
indicator,
|
|
curr_date,
|
|
)
|
|
except Exception as e:
|
|
print(
|
|
f"Error getting stockstats indicator data for indicator {indicator} on {curr_date}: {e}"
|
|
)
|
|
return ""
|
|
|
|
return str(indicator_value)
|
|
|
|
|
|
def get_technical_analysis(
|
|
symbol: Annotated[str, "ticker symbol of the company"],
|
|
curr_date: Annotated[str, "The current trading date, YYYY-mm-dd"],
|
|
) -> str:
|
|
"""
|
|
Get a concise technical analysis summary with key indicators, signals, and trend interpretation.
|
|
|
|
Returns analysis-ready output instead of verbose day-by-day data.
|
|
"""
|
|
from .config import get_config
|
|
from stockstats import wrap
|
|
|
|
# Default indicators to analyze
|
|
indicators = ["rsi", "stoch", "macd", "adx", "close_20_ema", "close_50_sma", "close_200_sma", "boll", "atr", "obv", "vwap", "fib"]
|
|
|
|
# Fetch price data (last 60 days for indicator calculation)
|
|
curr_date_dt = pd.to_datetime(curr_date)
|
|
start_date = curr_date_dt - pd.DateOffset(days=200) # Need enough history for 200 SMA
|
|
|
|
try:
|
|
data = yf.download(
|
|
symbol,
|
|
start=start_date.strftime("%Y-%m-%d"),
|
|
end=curr_date_dt.strftime("%Y-%m-%d"),
|
|
multi_level_index=False,
|
|
progress=False,
|
|
auto_adjust=True,
|
|
)
|
|
|
|
if data.empty:
|
|
return f"No data found for {symbol}"
|
|
|
|
data = data.reset_index()
|
|
df = wrap(data)
|
|
|
|
# Get latest values
|
|
latest = df.iloc[-1]
|
|
prev = df.iloc[-2] if len(df) > 1 else latest
|
|
prev_5 = df.iloc[-5] if len(df) > 5 else latest
|
|
|
|
current_price = float(latest['close'])
|
|
|
|
# Build analysis
|
|
analysis = []
|
|
analysis.append(f"# Technical Analysis for {symbol.upper()}")
|
|
analysis.append(f"**Date:** {curr_date}")
|
|
analysis.append(f"**Current Price:** ${current_price:.2f}")
|
|
analysis.append("")
|
|
|
|
# Price action summary
|
|
daily_change = ((current_price - float(prev['close'])) / float(prev['close'])) * 100
|
|
weekly_change = ((current_price - float(prev_5['close'])) / float(prev_5['close'])) * 100
|
|
analysis.append(f"## Price Action")
|
|
analysis.append(f"- **Daily Change:** {daily_change:+.2f}%")
|
|
analysis.append(f"- **5-Day Change:** {weekly_change:+.2f}%")
|
|
analysis.append("")
|
|
|
|
# RSI Analysis
|
|
if 'rsi' in indicators:
|
|
try:
|
|
df['rsi'] # Trigger calculation
|
|
rsi = float(df.iloc[-1]['rsi'])
|
|
rsi_prev = float(df.iloc[-5]['rsi']) if len(df) > 5 else rsi
|
|
|
|
if rsi > 70:
|
|
rsi_signal = "OVERBOUGHT ⚠️"
|
|
elif rsi < 30:
|
|
rsi_signal = "OVERSOLD ⚡"
|
|
elif rsi > 50:
|
|
rsi_signal = "Bullish"
|
|
else:
|
|
rsi_signal = "Bearish"
|
|
|
|
rsi_trend = "↑" if rsi > rsi_prev else "↓"
|
|
analysis.append(f"## RSI (14)")
|
|
analysis.append(f"- **Value:** {rsi:.1f} {rsi_trend}")
|
|
analysis.append(f"- **Signal:** {rsi_signal}")
|
|
analysis.append("")
|
|
except Exception as e:
|
|
pass
|
|
|
|
# MACD Analysis
|
|
if 'macd' in indicators:
|
|
try:
|
|
df['macd']
|
|
df['macds']
|
|
df['macdh']
|
|
macd = float(df.iloc[-1]['macd'])
|
|
signal = float(df.iloc[-1]['macds'])
|
|
histogram = float(df.iloc[-1]['macdh'])
|
|
hist_prev = float(df.iloc[-2]['macdh']) if len(df) > 1 else histogram
|
|
|
|
if macd > signal and histogram > 0:
|
|
macd_signal = "BULLISH CROSSOVER ⚡" if histogram > hist_prev else "Bullish"
|
|
elif macd < signal and histogram < 0:
|
|
macd_signal = "BEARISH CROSSOVER ⚠️" if histogram < hist_prev else "Bearish"
|
|
else:
|
|
macd_signal = "Neutral"
|
|
|
|
momentum = "Strengthening ↑" if abs(histogram) > abs(hist_prev) else "Weakening ↓"
|
|
analysis.append(f"## MACD")
|
|
analysis.append(f"- **MACD Line:** {macd:.3f}")
|
|
analysis.append(f"- **Signal Line:** {signal:.3f}")
|
|
analysis.append(f"- **Histogram:** {histogram:.3f} ({momentum})")
|
|
analysis.append(f"- **Signal:** {macd_signal}")
|
|
analysis.append("")
|
|
except Exception as e:
|
|
pass
|
|
|
|
# Moving Averages
|
|
if 'close_50_sma' in indicators or 'close_200_sma' in indicators:
|
|
try:
|
|
df['close_50_sma']
|
|
df['close_200_sma']
|
|
sma_50 = float(df.iloc[-1]['close_50_sma'])
|
|
sma_200 = float(df.iloc[-1]['close_200_sma'])
|
|
|
|
# Trend determination
|
|
if current_price > sma_50 > sma_200:
|
|
trend = "STRONG UPTREND ⚡"
|
|
elif current_price > sma_50:
|
|
trend = "Uptrend"
|
|
elif current_price < sma_50 < sma_200:
|
|
trend = "STRONG DOWNTREND ⚠️"
|
|
elif current_price < sma_50:
|
|
trend = "Downtrend"
|
|
else:
|
|
trend = "Sideways"
|
|
|
|
# Golden/Death cross detection
|
|
sma_50_prev = float(df.iloc[-5]['close_50_sma']) if len(df) > 5 else sma_50
|
|
sma_200_prev = float(df.iloc[-5]['close_200_sma']) if len(df) > 5 else sma_200
|
|
|
|
cross = ""
|
|
if sma_50 > sma_200 and sma_50_prev < sma_200_prev:
|
|
cross = " (GOLDEN CROSS ⚡)"
|
|
elif sma_50 < sma_200 and sma_50_prev > sma_200_prev:
|
|
cross = " (DEATH CROSS ⚠️)"
|
|
|
|
analysis.append(f"## Moving Averages")
|
|
analysis.append(f"- **50 SMA:** ${sma_50:.2f} ({'+' if current_price > sma_50 else ''}{((current_price - sma_50) / sma_50 * 100):.1f}% from price)")
|
|
analysis.append(f"- **200 SMA:** ${sma_200:.2f} ({'+' if current_price > sma_200 else ''}{((current_price - sma_200) / sma_200 * 100):.1f}% from price)")
|
|
analysis.append(f"- **Trend:** {trend}{cross}")
|
|
analysis.append("")
|
|
except Exception as e:
|
|
pass
|
|
|
|
# Bollinger Bands
|
|
if 'boll' in indicators:
|
|
try:
|
|
df['boll']
|
|
df['boll_ub']
|
|
df['boll_lb']
|
|
middle = float(df.iloc[-1]['boll'])
|
|
upper = float(df.iloc[-1]['boll_ub'])
|
|
lower = float(df.iloc[-1]['boll_lb'])
|
|
|
|
# Position within bands (0 = lower, 1 = upper)
|
|
band_position = (current_price - lower) / (upper - lower) if upper != lower else 0.5
|
|
|
|
if band_position > 0.95:
|
|
bb_signal = "AT UPPER BAND - Potential reversal ⚠️"
|
|
elif band_position < 0.05:
|
|
bb_signal = "AT LOWER BAND - Potential bounce ⚡"
|
|
elif band_position > 0.8:
|
|
bb_signal = "Near upper band"
|
|
elif band_position < 0.2:
|
|
bb_signal = "Near lower band"
|
|
else:
|
|
bb_signal = "Within bands"
|
|
|
|
bandwidth = ((upper - lower) / middle) * 100
|
|
analysis.append(f"## Bollinger Bands (20,2)")
|
|
analysis.append(f"- **Upper:** ${upper:.2f}")
|
|
analysis.append(f"- **Middle:** ${middle:.2f}")
|
|
analysis.append(f"- **Lower:** ${lower:.2f}")
|
|
analysis.append(f"- **Band Position:** {band_position:.0%}")
|
|
analysis.append(f"- **Bandwidth:** {bandwidth:.1f}% (volatility indicator)")
|
|
analysis.append(f"- **Signal:** {bb_signal}")
|
|
analysis.append("")
|
|
except Exception as e:
|
|
pass
|
|
|
|
# ATR (Volatility)
|
|
if 'atr' in indicators:
|
|
try:
|
|
df['atr']
|
|
atr = float(df.iloc[-1]['atr'])
|
|
atr_pct = (atr / current_price) * 100
|
|
|
|
if atr_pct > 5:
|
|
vol_level = "HIGH VOLATILITY ⚠️"
|
|
elif atr_pct > 2:
|
|
vol_level = "Moderate volatility"
|
|
else:
|
|
vol_level = "Low volatility"
|
|
|
|
analysis.append(f"## ATR (Volatility)")
|
|
analysis.append(f"- **ATR:** ${atr:.2f} ({atr_pct:.1f}% of price)")
|
|
analysis.append(f"- **Level:** {vol_level}")
|
|
analysis.append(f"- **Suggested Stop-Loss:** ${current_price - (1.5 * atr):.2f} (1.5x ATR)")
|
|
analysis.append("")
|
|
except Exception as e:
|
|
pass
|
|
|
|
# Stochastic Oscillator
|
|
if 'stoch' in indicators:
|
|
try:
|
|
df['kdjk'] # Stochastic %K
|
|
df['kdjd'] # Stochastic %D
|
|
stoch_k = float(df.iloc[-1]['kdjk'])
|
|
stoch_d = float(df.iloc[-1]['kdjd'])
|
|
stoch_k_prev = float(df.iloc[-2]['kdjk']) if len(df) > 1 else stoch_k
|
|
|
|
if stoch_k > 80 and stoch_d > 80:
|
|
stoch_signal = "OVERBOUGHT ⚠️"
|
|
elif stoch_k < 20 and stoch_d < 20:
|
|
stoch_signal = "OVERSOLD ⚡"
|
|
elif stoch_k > stoch_d and stoch_k_prev < stoch_d:
|
|
stoch_signal = "Bullish crossover ⚡"
|
|
elif stoch_k < stoch_d and stoch_k_prev > stoch_d:
|
|
stoch_signal = "Bearish crossover ⚠️"
|
|
elif stoch_k > 50:
|
|
stoch_signal = "Bullish"
|
|
else:
|
|
stoch_signal = "Bearish"
|
|
|
|
analysis.append(f"## Stochastic (14,3,3)")
|
|
analysis.append(f"- **%K:** {stoch_k:.1f}")
|
|
analysis.append(f"- **%D:** {stoch_d:.1f}")
|
|
analysis.append(f"- **Signal:** {stoch_signal}")
|
|
analysis.append("")
|
|
except Exception as e:
|
|
pass
|
|
|
|
# ADX (Trend Strength)
|
|
if 'adx' in indicators:
|
|
try:
|
|
df['adx']
|
|
df['dx']
|
|
adx = float(df.iloc[-1]['adx'])
|
|
adx_prev = float(df.iloc[-5]['adx']) if len(df) > 5 else adx
|
|
|
|
if adx > 50:
|
|
trend_strength = "VERY STRONG TREND ⚡"
|
|
elif adx > 25:
|
|
trend_strength = "Strong trend"
|
|
elif adx > 20:
|
|
trend_strength = "Trending"
|
|
else:
|
|
trend_strength = "WEAK/NO TREND (range-bound) ⚠️"
|
|
|
|
adx_direction = "Strengthening ↑" if adx > adx_prev else "Weakening ↓"
|
|
analysis.append(f"## ADX (Trend Strength)")
|
|
analysis.append(f"- **ADX:** {adx:.1f} ({adx_direction})")
|
|
analysis.append(f"- **Interpretation:** {trend_strength}")
|
|
analysis.append("")
|
|
except Exception as e:
|
|
pass
|
|
|
|
# 20 EMA (Short-term trend)
|
|
if 'close_20_ema' in indicators:
|
|
try:
|
|
df['close_20_ema']
|
|
ema_20 = float(df.iloc[-1]['close_20_ema'])
|
|
|
|
pct_from_ema = ((current_price - ema_20) / ema_20) * 100
|
|
if current_price > ema_20:
|
|
ema_signal = "Price ABOVE 20 EMA (short-term bullish)"
|
|
else:
|
|
ema_signal = "Price BELOW 20 EMA (short-term bearish)"
|
|
|
|
analysis.append(f"## 20 EMA")
|
|
analysis.append(f"- **Value:** ${ema_20:.2f} ({pct_from_ema:+.1f}% from price)")
|
|
analysis.append(f"- **Signal:** {ema_signal}")
|
|
analysis.append("")
|
|
except Exception as e:
|
|
pass
|
|
|
|
# OBV (On-Balance Volume)
|
|
if 'obv' in indicators:
|
|
try:
|
|
# Calculate OBV manually since stockstats may not have it
|
|
obv = 0
|
|
obv_values = [0]
|
|
for i in range(1, len(df)):
|
|
if float(df.iloc[i]['close']) > float(df.iloc[i-1]['close']):
|
|
obv += float(df.iloc[i]['volume'])
|
|
elif float(df.iloc[i]['close']) < float(df.iloc[i-1]['close']):
|
|
obv -= float(df.iloc[i]['volume'])
|
|
obv_values.append(obv)
|
|
|
|
current_obv = obv_values[-1]
|
|
obv_5_ago = obv_values[-5] if len(obv_values) > 5 else obv_values[0]
|
|
|
|
if current_obv > obv_5_ago and current_price > float(df.iloc[-5]['close']):
|
|
obv_signal = "Confirmed uptrend (price & volume rising)"
|
|
elif current_obv < obv_5_ago and current_price < float(df.iloc[-5]['close']):
|
|
obv_signal = "Confirmed downtrend (price & volume falling)"
|
|
elif current_obv > obv_5_ago and current_price < float(df.iloc[-5]['close']):
|
|
obv_signal = "BULLISH DIVERGENCE ⚡ (accumulation)"
|
|
elif current_obv < obv_5_ago and current_price > float(df.iloc[-5]['close']):
|
|
obv_signal = "BEARISH DIVERGENCE ⚠️ (distribution)"
|
|
else:
|
|
obv_signal = "Neutral"
|
|
|
|
obv_formatted = f"{current_obv/1e6:.1f}M" if abs(current_obv) > 1e6 else f"{current_obv/1e3:.1f}K"
|
|
analysis.append(f"## OBV (On-Balance Volume)")
|
|
analysis.append(f"- **Value:** {obv_formatted}")
|
|
analysis.append(f"- **5-Day Trend:** {'Rising ↑' if current_obv > obv_5_ago else 'Falling ↓'}")
|
|
analysis.append(f"- **Signal:** {obv_signal}")
|
|
analysis.append("")
|
|
except Exception as e:
|
|
pass
|
|
|
|
# VWAP (Volume Weighted Average Price)
|
|
if 'vwap' in indicators:
|
|
try:
|
|
# Calculate VWAP for today (simplified - using recent data)
|
|
typical_price = (float(df.iloc[-1]['high']) + float(df.iloc[-1]['low']) + float(df.iloc[-1]['close'])) / 3
|
|
|
|
# Calculate cumulative VWAP (last 20 periods approximation)
|
|
recent_df = df.tail(20)
|
|
tp_vol = ((recent_df['high'] + recent_df['low'] + recent_df['close']) / 3) * recent_df['volume']
|
|
vwap = float(tp_vol.sum() / recent_df['volume'].sum())
|
|
|
|
pct_from_vwap = ((current_price - vwap) / vwap) * 100
|
|
if current_price > vwap:
|
|
vwap_signal = "Price ABOVE VWAP (institutional buying)"
|
|
else:
|
|
vwap_signal = "Price BELOW VWAP (institutional selling)"
|
|
|
|
analysis.append(f"## VWAP (20-period)")
|
|
analysis.append(f"- **VWAP:** ${vwap:.2f}")
|
|
analysis.append(f"- **Current vs VWAP:** {pct_from_vwap:+.1f}%")
|
|
analysis.append(f"- **Signal:** {vwap_signal}")
|
|
analysis.append("")
|
|
except Exception as e:
|
|
pass
|
|
|
|
# Fibonacci Retracement Levels
|
|
if 'fib' in indicators:
|
|
try:
|
|
# Get high and low from last 50 periods
|
|
recent_high = float(df.tail(50)['high'].max())
|
|
recent_low = float(df.tail(50)['low'].min())
|
|
diff = recent_high - recent_low
|
|
|
|
fib_levels = {
|
|
"0.0% (High)": recent_high,
|
|
"23.6%": recent_high - (diff * 0.236),
|
|
"38.2%": recent_high - (diff * 0.382),
|
|
"50.0%": recent_high - (diff * 0.5),
|
|
"61.8%": recent_high - (diff * 0.618),
|
|
"78.6%": recent_high - (diff * 0.786),
|
|
"100% (Low)": recent_low,
|
|
}
|
|
|
|
# Find nearest support and resistance
|
|
support = None
|
|
resistance = None
|
|
for level_name, level_price in fib_levels.items():
|
|
if level_price < current_price and (support is None or level_price > support[1]):
|
|
support = (level_name, level_price)
|
|
if level_price > current_price and (resistance is None or level_price < resistance[1]):
|
|
resistance = (level_name, level_price)
|
|
|
|
analysis.append(f"## Fibonacci Levels (50-period)")
|
|
analysis.append(f"- **Recent High:** ${recent_high:.2f}")
|
|
analysis.append(f"- **Recent Low:** ${recent_low:.2f}")
|
|
if resistance:
|
|
analysis.append(f"- **Next Resistance:** ${resistance[1]:.2f} ({resistance[0]})")
|
|
if support:
|
|
analysis.append(f"- **Next Support:** ${support[1]:.2f} ({support[0]})")
|
|
analysis.append("")
|
|
except Exception as e:
|
|
pass
|
|
|
|
# Overall Summary
|
|
analysis.append("## Summary")
|
|
signals = []
|
|
|
|
# Collect all signals for summary
|
|
try:
|
|
rsi = float(df.iloc[-1]['rsi'])
|
|
if rsi > 70:
|
|
signals.append("RSI overbought")
|
|
elif rsi < 30:
|
|
signals.append("RSI oversold")
|
|
except:
|
|
pass
|
|
|
|
try:
|
|
if current_price > float(df.iloc[-1]['close_50_sma']):
|
|
signals.append("Above 50 SMA")
|
|
else:
|
|
signals.append("Below 50 SMA")
|
|
except:
|
|
pass
|
|
|
|
if signals:
|
|
analysis.append(f"- **Key Signals:** {', '.join(signals)}")
|
|
|
|
return "\n".join(analysis)
|
|
|
|
except Exception as e:
|
|
return f"Error analyzing {symbol}: {str(e)}"
|
|
|
|
|
|
def get_balance_sheet(
|
|
ticker: Annotated[str, "ticker symbol of the company"],
|
|
freq: Annotated[str, "frequency of data: 'annual' or 'quarterly'"] = "quarterly",
|
|
curr_date: Annotated[str, "current date (not used for yfinance)"] = None
|
|
):
|
|
"""Get balance sheet data from yfinance."""
|
|
try:
|
|
ticker_obj = yf.Ticker(ticker.upper())
|
|
|
|
if freq.lower() == "quarterly":
|
|
data = ticker_obj.quarterly_balance_sheet
|
|
else:
|
|
data = ticker_obj.balance_sheet
|
|
|
|
if data.empty:
|
|
return f"No balance sheet data found for symbol '{ticker}'"
|
|
|
|
# Convert to CSV string for consistency with other functions
|
|
csv_string = data.to_csv()
|
|
|
|
# Add header information
|
|
header = f"# Balance Sheet data for {ticker.upper()} ({freq})\n"
|
|
header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
|
|
|
|
return header + csv_string
|
|
|
|
except Exception as e:
|
|
return f"Error retrieving balance sheet for {ticker}: {str(e)}"
|
|
|
|
|
|
def get_cashflow(
|
|
ticker: Annotated[str, "ticker symbol of the company"],
|
|
freq: Annotated[str, "frequency of data: 'annual' or 'quarterly'"] = "quarterly",
|
|
curr_date: Annotated[str, "current date (not used for yfinance)"] = None
|
|
):
|
|
"""Get cash flow data from yfinance."""
|
|
try:
|
|
ticker_obj = yf.Ticker(ticker.upper())
|
|
|
|
if freq.lower() == "quarterly":
|
|
data = ticker_obj.quarterly_cashflow
|
|
else:
|
|
data = ticker_obj.cashflow
|
|
|
|
if data.empty:
|
|
return f"No cash flow data found for symbol '{ticker}'"
|
|
|
|
# Convert to CSV string for consistency with other functions
|
|
csv_string = data.to_csv()
|
|
|
|
# Add header information
|
|
header = f"# Cash Flow data for {ticker.upper()} ({freq})\n"
|
|
header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
|
|
|
|
return header + csv_string
|
|
|
|
except Exception as e:
|
|
return f"Error retrieving cash flow for {ticker}: {str(e)}"
|
|
|
|
|
|
def get_income_statement(
|
|
ticker: Annotated[str, "ticker symbol of the company"],
|
|
freq: Annotated[str, "frequency of data: 'annual' or 'quarterly'"] = "quarterly",
|
|
curr_date: Annotated[str, "current date (not used for yfinance)"] = None
|
|
):
|
|
"""Get income statement data from yfinance."""
|
|
try:
|
|
ticker_obj = yf.Ticker(ticker.upper())
|
|
|
|
if freq.lower() == "quarterly":
|
|
data = ticker_obj.quarterly_income_stmt
|
|
else:
|
|
data = ticker_obj.income_stmt
|
|
|
|
if data.empty:
|
|
return f"No income statement data found for symbol '{ticker}'"
|
|
|
|
# Convert to CSV string for consistency with other functions
|
|
csv_string = data.to_csv()
|
|
|
|
# Add header information
|
|
header = f"# Income Statement data for {ticker.upper()} ({freq})\n"
|
|
header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
|
|
|
|
return header + csv_string
|
|
|
|
except Exception as e:
|
|
return f"Error retrieving income statement for {ticker}: {str(e)}"
|
|
|
|
|
|
def get_insider_transactions(
|
|
ticker: Annotated[str, "ticker symbol of the company"],
|
|
curr_date: Annotated[str, "current date (not used for yfinance)"] = None
|
|
):
|
|
"""Get insider transactions data from yfinance with parsed transaction types."""
|
|
try:
|
|
ticker_obj = yf.Ticker(ticker.upper())
|
|
data = ticker_obj.insider_transactions
|
|
|
|
if data is None or data.empty:
|
|
return f"No insider transactions data found for symbol '{ticker}'"
|
|
|
|
# Parse the Text column to populate Transaction type
|
|
def classify_transaction(text):
|
|
if pd.isna(text) or text == '':
|
|
return 'Unknown'
|
|
text_lower = str(text).lower()
|
|
if 'sale' in text_lower:
|
|
return 'Sale'
|
|
elif 'purchase' in text_lower or 'buy' in text_lower:
|
|
return 'Purchase'
|
|
elif 'gift' in text_lower:
|
|
return 'Gift'
|
|
elif 'exercise' in text_lower or 'option' in text_lower:
|
|
return 'Option Exercise'
|
|
elif 'award' in text_lower or 'grant' in text_lower:
|
|
return 'Award/Grant'
|
|
elif 'conversion' in text_lower:
|
|
return 'Conversion'
|
|
else:
|
|
return 'Other'
|
|
|
|
# Apply classification
|
|
data['Transaction'] = data['Text'].apply(classify_transaction)
|
|
|
|
# Calculate summary statistics
|
|
transaction_counts = data['Transaction'].value_counts().to_dict()
|
|
total_sales_value = data[data['Transaction'] == 'Sale']['Value'].sum()
|
|
total_purchases_value = data[data['Transaction'] == 'Purchase']['Value'].sum()
|
|
|
|
# Determine insider sentiment
|
|
sales_count = transaction_counts.get('Sale', 0)
|
|
purchases_count = transaction_counts.get('Purchase', 0)
|
|
|
|
if purchases_count > sales_count:
|
|
sentiment = "BULLISH ⚡ (more buying than selling)"
|
|
elif sales_count > purchases_count * 2:
|
|
sentiment = "BEARISH ⚠️ (significant insider selling)"
|
|
elif sales_count > purchases_count:
|
|
sentiment = "Slightly bearish (more selling than buying)"
|
|
else:
|
|
sentiment = "Neutral"
|
|
|
|
# Build summary header
|
|
header = f"# Insider Transactions for {ticker.upper()}\n"
|
|
header += f"# Data retrieved on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
|
|
header += "## Summary\n"
|
|
header += f"- **Insider Sentiment:** {sentiment}\n"
|
|
for tx_type, count in sorted(transaction_counts.items(), key=lambda x: -x[1]):
|
|
header += f"- **{tx_type}:** {count} transactions\n"
|
|
if total_sales_value > 0:
|
|
header += f"- **Total Sales Value:** ${total_sales_value:,.0f}\n"
|
|
if total_purchases_value > 0:
|
|
header += f"- **Total Purchases Value:** ${total_purchases_value:,.0f}\n"
|
|
header += "\n## Transaction Details\n\n"
|
|
|
|
# Select key columns for output
|
|
output_cols = ['Start Date', 'Insider', 'Position', 'Transaction', 'Shares', 'Value', 'Ownership']
|
|
available_cols = [c for c in output_cols if c in data.columns]
|
|
|
|
csv_string = data[available_cols].to_csv(index=False)
|
|
|
|
return header + csv_string
|
|
|
|
except Exception as e:
|
|
return f"Error retrieving insider transactions for {ticker}: {str(e)}"
|
|
|
|
def validate_ticker(symbol: str) -> bool:
|
|
"""
|
|
Validate if a ticker symbol exists and has trading data.
|
|
"""
|
|
try:
|
|
ticker = yf.Ticker(symbol.upper())
|
|
# Use fast_info for lighter validation (no historical download needed)
|
|
# fast_info attributes are lazy-loaded
|
|
_ = ticker.fast_info.get("lastPrice")
|
|
return True
|
|
|
|
except Exception:
|
|
# Fallback to older method if fast_info fails or is missing
|
|
try:
|
|
return not ticker.history(period="1d", progress=False).empty
|
|
except:
|
|
return False
|
|
|
|
|
|
def get_fundamentals(
|
|
ticker: Annotated[str, "ticker symbol of the company"],
|
|
curr_date: Annotated[str, "current date (for reference)"] = None
|
|
) -> str:
|
|
"""
|
|
Get comprehensive fundamental data for a ticker using yfinance.
|
|
Returns data in a format similar to Alpha Vantage's OVERVIEW endpoint.
|
|
|
|
This is a FREE alternative to Alpha Vantage with no rate limits.
|
|
"""
|
|
import json
|
|
|
|
try:
|
|
ticker_obj = yf.Ticker(ticker.upper())
|
|
info = ticker_obj.info
|
|
|
|
if not info or info.get('regularMarketPrice') is None:
|
|
return f"No fundamental data found for symbol '{ticker}'"
|
|
|
|
# Build a structured response similar to Alpha Vantage
|
|
fundamentals = {
|
|
# Company Info
|
|
"Symbol": ticker.upper(),
|
|
"AssetType": info.get("quoteType", "N/A"),
|
|
"Name": info.get("longName", info.get("shortName", "N/A")),
|
|
"Description": info.get("longBusinessSummary", "N/A"),
|
|
"Exchange": info.get("exchange", "N/A"),
|
|
"Currency": info.get("currency", "USD"),
|
|
"Country": info.get("country", "N/A"),
|
|
"Sector": info.get("sector", "N/A"),
|
|
"Industry": info.get("industry", "N/A"),
|
|
"Address": f"{info.get('address1', '')} {info.get('city', '')}, {info.get('state', '')} {info.get('zip', '')}".strip(),
|
|
"OfficialSite": info.get("website", "N/A"),
|
|
"FiscalYearEnd": info.get("fiscalYearEnd", "N/A"),
|
|
|
|
# Valuation
|
|
"MarketCapitalization": str(info.get("marketCap", "N/A")),
|
|
"EBITDA": str(info.get("ebitda", "N/A")),
|
|
"PERatio": str(info.get("trailingPE", "N/A")),
|
|
"ForwardPE": str(info.get("forwardPE", "N/A")),
|
|
"PEGRatio": str(info.get("pegRatio", "N/A")),
|
|
"BookValue": str(info.get("bookValue", "N/A")),
|
|
"PriceToBookRatio": str(info.get("priceToBook", "N/A")),
|
|
"PriceToSalesRatioTTM": str(info.get("priceToSalesTrailing12Months", "N/A")),
|
|
"EVToRevenue": str(info.get("enterpriseToRevenue", "N/A")),
|
|
"EVToEBITDA": str(info.get("enterpriseToEbitda", "N/A")),
|
|
|
|
# Earnings & Revenue
|
|
"EPS": str(info.get("trailingEps", "N/A")),
|
|
"ForwardEPS": str(info.get("forwardEps", "N/A")),
|
|
"RevenueTTM": str(info.get("totalRevenue", "N/A")),
|
|
"RevenuePerShareTTM": str(info.get("revenuePerShare", "N/A")),
|
|
"GrossProfitTTM": str(info.get("grossProfits", "N/A")),
|
|
"QuarterlyRevenueGrowthYOY": str(info.get("revenueGrowth", "N/A")),
|
|
"QuarterlyEarningsGrowthYOY": str(info.get("earningsGrowth", "N/A")),
|
|
|
|
# Margins & Returns
|
|
"ProfitMargin": str(info.get("profitMargins", "N/A")),
|
|
"OperatingMarginTTM": str(info.get("operatingMargins", "N/A")),
|
|
"GrossMargins": str(info.get("grossMargins", "N/A")),
|
|
"ReturnOnAssetsTTM": str(info.get("returnOnAssets", "N/A")),
|
|
"ReturnOnEquityTTM": str(info.get("returnOnEquity", "N/A")),
|
|
|
|
# Dividend
|
|
"DividendPerShare": str(info.get("dividendRate", "N/A")),
|
|
"DividendYield": str(info.get("dividendYield", "N/A")),
|
|
"ExDividendDate": str(info.get("exDividendDate", "N/A")),
|
|
"PayoutRatio": str(info.get("payoutRatio", "N/A")),
|
|
|
|
# Balance Sheet
|
|
"TotalCash": str(info.get("totalCash", "N/A")),
|
|
"TotalDebt": str(info.get("totalDebt", "N/A")),
|
|
"CurrentRatio": str(info.get("currentRatio", "N/A")),
|
|
"QuickRatio": str(info.get("quickRatio", "N/A")),
|
|
"DebtToEquity": str(info.get("debtToEquity", "N/A")),
|
|
"FreeCashFlow": str(info.get("freeCashflow", "N/A")),
|
|
"OperatingCashFlow": str(info.get("operatingCashflow", "N/A")),
|
|
|
|
# Trading Info
|
|
"Beta": str(info.get("beta", "N/A")),
|
|
"52WeekHigh": str(info.get("fiftyTwoWeekHigh", "N/A")),
|
|
"52WeekLow": str(info.get("fiftyTwoWeekLow", "N/A")),
|
|
"50DayMovingAverage": str(info.get("fiftyDayAverage", "N/A")),
|
|
"200DayMovingAverage": str(info.get("twoHundredDayAverage", "N/A")),
|
|
"SharesOutstanding": str(info.get("sharesOutstanding", "N/A")),
|
|
"SharesFloat": str(info.get("floatShares", "N/A")),
|
|
"SharesShort": str(info.get("sharesShort", "N/A")),
|
|
"ShortRatio": str(info.get("shortRatio", "N/A")),
|
|
"ShortPercentOfFloat": str(info.get("shortPercentOfFloat", "N/A")),
|
|
|
|
# Ownership
|
|
"PercentInsiders": str(info.get("heldPercentInsiders", "N/A")),
|
|
"PercentInstitutions": str(info.get("heldPercentInstitutions", "N/A")),
|
|
|
|
# Analyst
|
|
"AnalystTargetPrice": str(info.get("targetMeanPrice", "N/A")),
|
|
"AnalystTargetHigh": str(info.get("targetHighPrice", "N/A")),
|
|
"AnalystTargetLow": str(info.get("targetLowPrice", "N/A")),
|
|
"NumberOfAnalysts": str(info.get("numberOfAnalystOpinions", "N/A")),
|
|
"RecommendationKey": info.get("recommendationKey", "N/A"),
|
|
"RecommendationMean": str(info.get("recommendationMean", "N/A")),
|
|
}
|
|
|
|
# Return as formatted JSON string
|
|
return json.dumps(fundamentals, indent=4)
|
|
|
|
except Exception as e:
|
|
return f"Error retrieving fundamentals for {ticker}: {str(e)}"
|
|
|
|
|
|
def get_options_activity(
|
|
ticker: Annotated[str, "ticker symbol of the company"],
|
|
num_expirations: Annotated[int, "number of nearest expiration dates to analyze"] = 3,
|
|
curr_date: Annotated[str, "current date (for reference)"] = None
|
|
) -> str:
|
|
"""
|
|
Get options activity for a specific ticker using yfinance.
|
|
Analyzes volume, open interest, and put/call ratios.
|
|
|
|
This is a FREE alternative to Tradier with no API key required.
|
|
"""
|
|
try:
|
|
ticker_obj = yf.Ticker(ticker.upper())
|
|
|
|
# Get available expiration dates
|
|
expirations = ticker_obj.options
|
|
if not expirations:
|
|
return f"No options data available for {ticker}"
|
|
|
|
# Analyze the nearest N expiration dates
|
|
expirations_to_analyze = expirations[:min(num_expirations, len(expirations))]
|
|
|
|
report = f"## Options Activity for {ticker.upper()}\n\n"
|
|
report += f"**Available Expirations:** {len(expirations)} dates\n"
|
|
report += f"**Analyzing:** {', '.join(expirations_to_analyze)}\n\n"
|
|
|
|
total_call_volume = 0
|
|
total_put_volume = 0
|
|
total_call_oi = 0
|
|
total_put_oi = 0
|
|
|
|
unusual_activity = []
|
|
|
|
for exp_date in expirations_to_analyze:
|
|
try:
|
|
opt = ticker_obj.option_chain(exp_date)
|
|
calls = opt.calls
|
|
puts = opt.puts
|
|
|
|
if calls.empty and puts.empty:
|
|
continue
|
|
|
|
# Calculate totals for this expiration
|
|
call_vol = calls['volume'].sum() if 'volume' in calls.columns else 0
|
|
put_vol = puts['volume'].sum() if 'volume' in puts.columns else 0
|
|
call_oi = calls['openInterest'].sum() if 'openInterest' in calls.columns else 0
|
|
put_oi = puts['openInterest'].sum() if 'openInterest' in puts.columns else 0
|
|
|
|
# Handle NaN values
|
|
call_vol = 0 if pd.isna(call_vol) else int(call_vol)
|
|
put_vol = 0 if pd.isna(put_vol) else int(put_vol)
|
|
call_oi = 0 if pd.isna(call_oi) else int(call_oi)
|
|
put_oi = 0 if pd.isna(put_oi) else int(put_oi)
|
|
|
|
total_call_volume += call_vol
|
|
total_put_volume += put_vol
|
|
total_call_oi += call_oi
|
|
total_put_oi += put_oi
|
|
|
|
# Find unusual activity (high volume relative to OI)
|
|
for _, row in calls.iterrows():
|
|
vol = row.get('volume', 0)
|
|
oi = row.get('openInterest', 0)
|
|
if pd.notna(vol) and pd.notna(oi) and oi > 0 and vol > oi * 0.5 and vol > 100:
|
|
unusual_activity.append({
|
|
'type': 'CALL',
|
|
'expiration': exp_date,
|
|
'strike': row['strike'],
|
|
'volume': int(vol),
|
|
'openInterest': int(oi),
|
|
'vol_oi_ratio': round(vol / oi, 2) if oi > 0 else 0,
|
|
'impliedVolatility': round(row.get('impliedVolatility', 0) * 100, 1)
|
|
})
|
|
|
|
for _, row in puts.iterrows():
|
|
vol = row.get('volume', 0)
|
|
oi = row.get('openInterest', 0)
|
|
if pd.notna(vol) and pd.notna(oi) and oi > 0 and vol > oi * 0.5 and vol > 100:
|
|
unusual_activity.append({
|
|
'type': 'PUT',
|
|
'expiration': exp_date,
|
|
'strike': row['strike'],
|
|
'volume': int(vol),
|
|
'openInterest': int(oi),
|
|
'vol_oi_ratio': round(vol / oi, 2) if oi > 0 else 0,
|
|
'impliedVolatility': round(row.get('impliedVolatility', 0) * 100, 1)
|
|
})
|
|
|
|
except Exception as e:
|
|
report += f"*Error fetching {exp_date}: {str(e)}*\n"
|
|
continue
|
|
|
|
# Calculate put/call ratios
|
|
pc_volume_ratio = round(total_put_volume / total_call_volume, 3) if total_call_volume > 0 else 0
|
|
pc_oi_ratio = round(total_put_oi / total_call_oi, 3) if total_call_oi > 0 else 0
|
|
|
|
# Summary
|
|
report += "### Summary\n"
|
|
report += "| Metric | Calls | Puts | Put/Call Ratio |\n"
|
|
report += "|--------|-------|------|----------------|\n"
|
|
report += f"| Volume | {total_call_volume:,} | {total_put_volume:,} | {pc_volume_ratio} |\n"
|
|
report += f"| Open Interest | {total_call_oi:,} | {total_put_oi:,} | {pc_oi_ratio} |\n\n"
|
|
|
|
# Sentiment interpretation
|
|
report += "### Sentiment Analysis\n"
|
|
if pc_volume_ratio < 0.7:
|
|
report += "- **Volume P/C Ratio:** Bullish (more call volume)\n"
|
|
elif pc_volume_ratio > 1.3:
|
|
report += "- **Volume P/C Ratio:** Bearish (more put volume)\n"
|
|
else:
|
|
report += "- **Volume P/C Ratio:** Neutral\n"
|
|
|
|
if pc_oi_ratio < 0.7:
|
|
report += "- **OI P/C Ratio:** Bullish positioning\n"
|
|
elif pc_oi_ratio > 1.3:
|
|
report += "- **OI P/C Ratio:** Bearish positioning\n"
|
|
else:
|
|
report += "- **OI P/C Ratio:** Neutral positioning\n"
|
|
|
|
# Unusual activity
|
|
if unusual_activity:
|
|
# Sort by volume/OI ratio
|
|
unusual_activity.sort(key=lambda x: x['vol_oi_ratio'], reverse=True)
|
|
top_unusual = unusual_activity[:10]
|
|
|
|
report += "\n### Unusual Activity (High Volume vs Open Interest)\n"
|
|
report += "| Type | Expiry | Strike | Volume | OI | Vol/OI | IV |\n"
|
|
report += "|------|--------|--------|--------|----|---------|----|---|\n"
|
|
for item in top_unusual:
|
|
report += f"| {item['type']} | {item['expiration']} | ${item['strike']} | {item['volume']:,} | {item['openInterest']:,} | {item['vol_oi_ratio']}x | {item['impliedVolatility']}% |\n"
|
|
else:
|
|
report += "\n*No unusual options activity detected.*\n"
|
|
|
|
return report
|
|
|
|
except Exception as e:
|
|
return f"Error retrieving options activity for {ticker}: {str(e)}"
|
|
|
|
|
|
def _get_ticker_universe(
|
|
tickers: Optional[Union[str, List[str]]] = None,
|
|
max_tickers: Optional[int] = None
|
|
) -> List[str]:
|
|
"""
|
|
Get a list of ticker symbols.
|
|
|
|
Args:
|
|
tickers: List of ticker symbols, or None to load from config file
|
|
max_tickers: Maximum number of tickers to return (None = all)
|
|
|
|
Returns:
|
|
List of ticker symbols
|
|
"""
|
|
# If custom list provided, use it
|
|
if isinstance(tickers, list):
|
|
ticker_list = [t.upper().strip() for t in tickers if t and isinstance(t, str)]
|
|
return ticker_list[:max_tickers] if max_tickers else ticker_list
|
|
|
|
# Load from config file
|
|
from tradingagents.default_config import DEFAULT_CONFIG
|
|
ticker_file = DEFAULT_CONFIG.get("tickers_file")
|
|
|
|
if not ticker_file:
|
|
print("Warning: tickers_file not configured, using fallback list")
|
|
return _get_default_tickers()[:max_tickers] if max_tickers else _get_default_tickers()
|
|
|
|
# Load tickers from file
|
|
try:
|
|
ticker_path = Path(ticker_file)
|
|
if ticker_path.exists():
|
|
with open(ticker_path, 'r') as f:
|
|
ticker_list = [line.strip().upper() for line in f if line.strip()]
|
|
# Remove duplicates while preserving order
|
|
seen = set()
|
|
ticker_list = [t for t in ticker_list if t and t not in seen and not seen.add(t)]
|
|
return ticker_list[:max_tickers] if max_tickers else ticker_list
|
|
else:
|
|
print(f"Warning: Ticker file not found at {ticker_file}, using fallback list")
|
|
return _get_default_tickers()[:max_tickers] if max_tickers else _get_default_tickers()
|
|
except Exception as e:
|
|
print(f"Warning: Could not load ticker list from file: {e}, using fallback")
|
|
return _get_default_tickers()[:max_tickers] if max_tickers else _get_default_tickers()
|
|
|
|
|
|
def _get_default_tickers() -> List[str]:
|
|
"""Fallback list of major US stocks if ticker file is not found."""
|
|
return [
|
|
"AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "META", "TSLA", "BRK-B", "V", "UNH",
|
|
"XOM", "JNJ", "JPM", "WMT", "MA", "PG", "LLY", "AVGO", "HD", "MRK",
|
|
"COST", "ABBV", "PEP", "ADBE", "TMO", "CSCO", "NFLX", "ACN", "DHR", "ABT",
|
|
"VZ", "WFC", "CRM", "PM", "LIN", "DIS", "BMY", "NKE", "TXN", "RTX",
|
|
"QCOM", "UPS", "HON", "AMGN", "DE", "INTU", "AMAT", "LOW", "SBUX", "C",
|
|
"BKNG", "ADP", "GE", "TJX", "AXP", "SPGI", "MDT", "GILD", "ISRG", "BLK",
|
|
"SYK", "ZTS", "CI", "CME", "ICE", "EQIX", "REGN", "APH", "KLAC", "CDNS",
|
|
"SNPS", "MCHP", "FTNT", "ANSS", "CTSH", "WDAY", "ON", "NXPI", "MPWR", "CRWD",
|
|
"AMD", "INTC", "MU", "LRCX", "PANW", "NOW", "DDOG", "ZS", "NET", "TEAM"
|
|
]
|
|
|
|
|
|
def get_pre_earnings_accumulation_signal(
|
|
ticker: Annotated[str, "ticker symbol to analyze"],
|
|
lookback_days: Annotated[int, "days to analyze volume"] = 10,
|
|
) -> dict:
|
|
"""
|
|
Detect if a stock is being accumulated BEFORE earnings (LEADING INDICATOR).
|
|
|
|
SIGNAL: Volume increases while price stays flat = Smart money accumulating
|
|
|
|
This happens BEFORE the price run, giving you an early entry.
|
|
Returns a dict with signal strength and metrics.
|
|
|
|
Args:
|
|
ticker: Stock symbol to check
|
|
lookback_days: Recent days to analyze
|
|
|
|
Returns:
|
|
Dict with 'signal' (bool), 'volume_ratio' (float), 'price_change_pct' (float), 'current_price' (float)
|
|
"""
|
|
try:
|
|
stock = yf.Ticker(ticker.upper())
|
|
|
|
# Get 1 month of data to calculate baseline
|
|
hist = stock.history(period="1mo")
|
|
if len(hist) < 20:
|
|
return {'signal': False, 'reason': 'Insufficient data'}
|
|
|
|
# Baseline volume (excluding recent period)
|
|
baseline_volume = hist['Volume'][:-lookback_days].mean()
|
|
|
|
# Recent volume
|
|
recent_volume = hist['Volume'][-lookback_days:].mean()
|
|
|
|
# Volume ratio
|
|
volume_ratio = recent_volume / baseline_volume if baseline_volume > 0 else 0
|
|
|
|
# Price movement in recent period
|
|
price_start = hist['Close'].iloc[-lookback_days]
|
|
price_end = hist['Close'].iloc[-1]
|
|
price_change_pct = ((price_end - price_start) / price_start) * 100
|
|
|
|
# SIGNAL CRITERIA:
|
|
# - Volume up at least 50% (1.5x)
|
|
# - Price relatively flat (< 5% move)
|
|
accumulation_signal = volume_ratio >= 1.5 and abs(price_change_pct) < 5.0
|
|
|
|
return {
|
|
'signal': accumulation_signal,
|
|
'volume_ratio': round(volume_ratio, 2),
|
|
'price_change_pct': round(price_change_pct, 2),
|
|
'current_price': round(price_end, 2),
|
|
'baseline_volume': int(baseline_volume),
|
|
'recent_volume': int(recent_volume),
|
|
}
|
|
|
|
except Exception as e:
|
|
return {'signal': False, 'reason': str(e)}
|
|
|
|
|
|
def check_if_price_reacted(
|
|
ticker: Annotated[str, "ticker symbol to analyze"],
|
|
lookback_days: Annotated[int, "days to check for price reaction"] = 3,
|
|
reaction_threshold: Annotated[float, "% change to consider as 'reacted'"] = 5.0,
|
|
) -> dict:
|
|
"""
|
|
Check if a stock's price has already reacted to news/catalyst.
|
|
|
|
Use this to determine if a catalyst (analyst upgrade, news, etc.) is LEADING or LAGGING:
|
|
- If price hasn't moved much = LEADING indicator (you're early)
|
|
- If price already moved significantly = LAGGING indicator (you're late)
|
|
|
|
Args:
|
|
ticker: Stock symbol to check
|
|
lookback_days: Days to check for reaction (default 3)
|
|
reaction_threshold: Price change % to consider as "reacted" (default 5%)
|
|
|
|
Returns:
|
|
Dict with 'reacted' (bool), 'price_change_pct' (float), 'status' (str: 'leading' or 'lagging')
|
|
"""
|
|
try:
|
|
stock = yf.Ticker(ticker.upper())
|
|
|
|
# Get recent history
|
|
hist = stock.history(period="1mo")
|
|
if len(hist) < lookback_days:
|
|
return {'reacted': None, 'reason': 'Insufficient data', 'status': 'unknown'}
|
|
|
|
# Check price movement in lookback period
|
|
price_start = hist['Close'].iloc[-lookback_days]
|
|
price_end = hist['Close'].iloc[-1]
|
|
price_change_pct = ((price_end - price_start) / price_start) * 100
|
|
|
|
# Determine if already reacted
|
|
reacted = abs(price_change_pct) >= reaction_threshold
|
|
|
|
return {
|
|
'reacted': reacted,
|
|
'price_change_pct': round(price_change_pct, 2),
|
|
'status': 'lagging' if reacted else 'leading',
|
|
'current_price': round(price_end, 2),
|
|
}
|
|
|
|
except Exception as e:
|
|
return {'reacted': None, 'reason': str(e), 'status': 'unknown'} |