QUARTERLY INSTITUTIONAL INTELLIGENCE
SEC 13F Smart Money Report
2026-04-08 · 13 Monitored Institutions · Top 5 Picks
Market Context
The market appears to be experiencing significant institutional repositioning into AI infrastructure, defensive value plays, and alternative assets including crypto ETFs. Notable convergence among elite funds on mega-cap tech suggests consensus building around AI beneficiaries despite potential valuation concerns.
🎯 Top 5 Conviction Picks + Option Trades
PLTR
PALANTIR TECHNOLOGIES INC
100.0/100
CONVICTION SCORE
Investment Thesis
TCI Fund's massive 66% portfolio allocation signals extraordinary conviction in Palantir's AI/data analytics platform amid government and enterprise adoption acceleration. Chris Hohn's concentrated bet suggests transformational growth expectations in the AI infrastructure space.
KEY BUYERS
TCI Fund (Chris Hohn)
RISK NOTE
Extreme concentration risk given 66% portfolio weight; government contract dependency and competitive AI landscape present execution risks.
📈 RECOMMENDED OPTION TRADE
SYMBOL
PLTR260821C00150000
TYPE / STRIKE
CALL @ $150.0
MAX RISK / CONTRACT
$1718.0
PROFIT TARGET
+80-120% on option premium if stock moves +20-25%
Rationale: Delta 0.55 provides strong directional exposure matching highest conviction thesis. 4+ month expiry allows government/enterprise adoption cycles to develop.
Stop Loss: -50% on option premium |
Greeks: Available
AMZN
AMAZON COM INC
21.0/100
CONVICTION SCORE
Investment Thesis
Six elite institutions simultaneously initiated positions including Pershing Square, Harvard, and Tiger Global, suggesting broad consensus on Amazon's AI cloud dominance and retail resilience. The coordinated buying pattern indicates institutional recognition of Amazon's multiple growth vectors.
KEY BUYERS
Harvard Management Co, Pershing Square (Ackman), Tiger Global (Coleman), D1 Capital (Sundheim), Viking Global (Halvorsen), AQR Capital (Asness)
RISK NOTE
Regulatory scrutiny and competitive pressures in cloud computing; mature e-commerce growth may limit upside.
📈 RECOMMENDED OPTION TRADE
SYMBOL
AMZN260821C00250000
TYPE / STRIKE
CALL @ $250.0
MAX RISK / CONTRACT
$970.0
PROFIT TARGET
+75-100% on option premium if stock moves +12-18%
Rationale: Delta 0.35 provides optimal risk-reward leverage for 4+ month time horizon, while 34.4% IV is reasonable for tech. Exceptional liquidity with 29,781 OI.
Stop Loss: -50% on option premium |
Greeks: Available
NVDA
NVIDIA CORPORATION
19.8/100
CONVICTION SCORE
Investment Thesis
Five top-tier funds including TCI and Harvard established new positions, signaling continued institutional confidence in NVIDIA's AI chip monopoly despite valuation concerns. The broad-based buying suggests institutions view current levels as attractive entry points.
KEY BUYERS
Harvard Management Co, TCI Fund (Chris Hohn), Tiger Global (Coleman), D1 Capital (Sundheim), AQR Capital (Asness)
RISK NOTE
High valuation multiples and potential AI bubble concerns; semiconductor cyclicality and geopolitical tensions around China markets.
📈 RECOMMENDED OPTION TRADE
SYMBOL
NVDA260918C00200000
TYPE / STRIKE
CALL @ $200.0
MAX RISK / CONTRACT
$1273.0
PROFIT TARGET
+60-80% on option premium if stock moves +15-20%
Rationale: Delta 0.43 offers strong directional exposure with 5+ month runway for AI thesis to materialize. High liquidity with 33,190 OI provides excellent execution.
Stop Loss: |
Greeks: Available
BRK/A
BERKSHIRE HATHAWAY INC DEL
41.3/100
CONVICTION SCORE
Investment Thesis
Gates Foundation's substantial 27.6% allocation to Berkshire signals flight to defensive value and Buffett's crisis-tested investment acumen. This concentrated bet suggests institutional preparation for market volatility while maintaining equity exposure.
KEY BUYERS
Gates Foundation Trust
RISK NOTE
Succession concerns post-Buffett era; large cash position may drag returns in bull markets; concentrated exposure to specific sectors.
📈 RECOMMENDED OPTION TRADE
PROFIT TARGET
N/A - Direct equity purchase required
Rationale: No options data available for BRK/A - would require direct equity exposure to capture Gates Foundation's flight-to-quality thesis.
Stop Loss: N/A |
Greeks: N/A
IBIT
ISHARES BITCOIN TRUST ETF
18.7/100
CONVICTION SCORE
Investment Thesis
Harvard and Brown's simultaneous crypto ETF adoption marks institutional acceptance of Bitcoin as a legitimate asset class. The 12.8% Harvard allocation suggests endowments are diversifying into digital assets for long-term portfolio protection.
KEY BUYERS
Harvard Management Co, Brown University
RISK NOTE
Extreme Bitcoin volatility and regulatory uncertainty; ETF structure risks and potential crypto market manipulation concerns.
📈 RECOMMENDED OPTION TRADE
SYMBOL
IBIT260918C00045000
TYPE / STRIKE
CALL @ $45.0
MAX RISK / CONTRACT
$363.0
PROFIT TARGET
+100-150% on option premium if Bitcoin rallies +25-35%
Rationale: Delta 0.44 provides balanced risk-reward with 5+ month horizon for crypto institutional adoption trend. Excellent OI at 25,501 ensures liquidity.
Stop Loss: -60% on option premium due to crypto volatility |
Greeks: Available
Portfolio Sizing Note
Weight AMZN and NVDA highest given broad institutional consensus, moderate allocation to PLTR despite high conviction given concentration risk, small speculative allocation to IBIT.
⚠️ DISCLAIMER: Options involve significant risk. This is based on delayed 13F data and real-time option prices may differ. Not investment advice.
Data limitations: 13F filings reflect long equity positions over $200K with up to 45-day delay.
Portfolio weights use long-only reported AUM (cash, shorts, bonds excluded – weights are systematically overstated).
Stock splits have been adjusted. Option prices are from Tradier at time of analysis and change constantly.
This report is generated automatically and does not constitute investment advice.
Generated automatically by SEC 13F Smart Money Analyzer ·
Data: SEC EDGAR + Tradier · Analysis: Claude AI
================================================
FILE: reports/2026-05-18_report.html
================================================
QUARTERLY INSTITUTIONAL INTELLIGENCE
SEC 13F Smart Money Report
2026-05-18 · 13 Monitored Institutions · Top 5 Picks
Market Context
Institutional investors are showing strong synchronized conviction in mega-cap tech (NVDA, MSFT, GOOGL, AMZN) and semiconductor supply chain (TSM, AVGO), suggesting a coordinated thesis around AI infrastructure and edge computing. Simultaneous entries by elite endowments (Harvard, Brown) and specialized hedge funds (D1, Tiger Global, Viking) into both traditional blue chips and emerging fintech/e-commerce names indicate portfolio repositioning toward structural growth themes with reduced economic sensitivity.
🎯 Top 5 Conviction Picks + Option Trades
NVDA
NVIDIA Corporation
94.2/100
CONVICTION SCORE
CLUSTER
Investment Thesis
Unprecedented 7-fund cluster conviction including elite endowments (Harvard, Brown, TCI) and specialized tech allocators (Situational Awareness, Tiger Global, D1), with 11.47% portfolio weight in Situational Awareness suggesting AI infrastructure is a core thesis. New positions across all major allocators indicate synchronized recognition of sustained AI/data center demand tailwinds beyond near-term consensus.
KEY BUYERS
Situational Awareness LP, Harvard Management Co, Brown University, TCI Fund (Chris Hohn), Tiger Global (Coleman), D1 Capital (Sundheim), AQR Capital (Asness)
RISK NOTE
Stock has already benefited significantly from AI narrative and may be priced for optimistic scenarios; 45-day lag means these positions were established in late April 2026 and could already reflect partial moves.
📈 RECOMMENDED OPTION TRADE
SYMBOL
NVDA260918C00240000
TYPE / STRIKE
CALL @ $240.0
MAX RISK / CONTRACT
$1615.0
PROFIT TARGET
+60-90% on option premium if NVDA moves to $255-265 (+16-20%) by August-September
Rationale: Strike at +9% OTM with Delta 0.45 sits in the sweet spot for leveraged bullish exposure without overpaying for proximity. September 18 expiry provides sufficient runway for AI capex cycle catalysts (earnings, data center announcements). IV at 44.8% is consistent with peer strikes, no premium anomaly. Volume 2547 and OI 32666 represent the highest liquidity in the NVDA chain, minimizing slippage. Spread% of 0.6% is exceptionally tight for a high-beta name.
Stop Loss: -50% on option premium (~$8.08 per contract) |
Greeks: Available
TSM
Taiwan Semiconductor Manufacturing Company
100.0/100
CONVICTION SCORE
HIGH_CONVICTION
Investment Thesis
Perfect conviction score with 5-fund cluster of highest-quality allocators (Situational Awareness 6.56%, Harvard 12.78%, Tiger Global 8.23%) entering simultaneously across borders, indicating structural confidence in semiconductor supply chain leadership. TSM's role as critical infrastructure for AI/GPU manufacturing makes it a proxy play on sustained capex cycles with less crowding than direct chip designers.
KEY BUYERS
Situational Awareness LP, Harvard Management Co, Tiger Global (Coleman), D1 Capital (Sundheim), Viking Global (Halvorsen)
RISK NOTE
Geopolitical concentration risk (Taiwan) and US-China tensions could create volatility; new position status means conviction narrative may still be building and subject to reversal if foundational AI thesis weakens.
📈 RECOMMENDED OPTION TRADE
SYMBOL
TSM260918C00390000
TYPE / STRIKE
CALL @ $390.0
MAX RISK / CONTRACT
$4435.0
PROFIT TARGET
+40-65% on option premium if TSM moves to $430-450 (+10-15%) by September
Rationale: Strike at -0.6% (essentially ATM) with Delta 0.59 reflects higher conviction warranted by the elite fund cluster quality and TSM's structural moat. September expiry aligns with Q2 earnings catalyst and potential positive AI demand commentary. IV at 45.6% is reasonable for a name with geopolitical risk premium. Volume 176 and OI 1206 are adequate though lower than NVDA; spread at 2.0% is acceptable. ATM positioning maximizes delta sensitivity to upside moves while providing intrinsic value buffer against time decay.
Stop Loss: -45% on option premium (~$19.96 per contract) |
Greeks: Available
AVGO
Broadcom Inc
95.2/100
CONVICTION SCORE
CLUSTER
Investment Thesis
5-fund cluster including Harvard (8.08%), Situational Awareness (7.36%), and specialized tech allocators (Tiger Global, D1, AQR) capturing semiconductor supply chain exposure with lower visibility than NVDA. As critical infrastructure provider for networking/connectivity in data centers, AVGO represents a complementary bet to NVDA with less consensus coverage and fresher accumulation pattern.
KEY BUYERS
Situational Awareness LP, Harvard Management Co, Tiger Global (Coleman), D1 Capital (Sundheim), AQR Capital (Asness)
RISK NOTE
Cyclical exposure to capex spending means thesis is sensitive to data center investment slowdown; new position timing suggests this is momentum-driven rather than deep-value setup.
📈 RECOMMENDED OPTION TRADE
SYMBOL
AVGO261016C00430000
TYPE / STRIKE
CALL @ $430.0
MAX RISK / CONTRACT
$5145.0
PROFIT TARGET
+50-75% on option premium if AVGO moves to $480-500 (+15-20%) by October
Rationale: Strike at +2.8% OTM with Delta 0.55 and October 16 expiry provides the longest time horizon available for AVGO while maintaining near-ATM sensitivity. October expiry is preferred over August to avoid theta decay pressure during what may be a gradual institutional accumulation story. Volume 111 and OI 1410 are adequate; spread at 2.3% is acceptable. IV at 50.6% is the highest in this selection but reflects AVGO's genuine higher volatility profile versus MSFT; compared to AVGO's own chain, the October strike is not an outlier. The additional month over September peers justifies the small IV premium.
Stop Loss: -50% on option premium (~$25.73 per contract) |
Greeks: Available
BKNG
Booking Holdings Inc
95.2/100
CONVICTION SCORE
HIGH_CONVICTION
✅ +0.0% seit Filing – Signal noch frisch$154.13 → $154.13 · 3d ago
Investment Thesis
Selective 2-fund entry by Harvard Management (8.10% weight) and AQR Capital representing rare consensus between endowment and quant allocators in travel/tourism recovery play. High portfolio concentration at Harvard suggests conviction in structural travel demand resilience post-cycle, with less crowding than mega-cap tech and better economic sensitivity profile for diversification.
KEY BUYERS
Harvard Management Co, AQR Capital (Asness)
RISK NOTE
Macro sensitivity to consumer spending and recession risk; only 2-fund signal is weaker than mega-cap tech cluster and thesis may reflect cyclical recovery optimism rather than structural growth.
📈 RECOMMENDED OPTION TRADE
SYMBOL
BKNG260918C00180000
TYPE / STRIKE
CALL @ $180.0
MAX RISK / CONTRACT
$630.0
PROFIT TARGET
+80-120% on option premium if BKNG moves to $195-205 (+27-33%) driven by travel demand surprise
Rationale: Strike at +16.9% OTM with Delta 0.31 reflects the appropriate risk-sizing for the weakest conviction signal in this portfolio (2-fund vs 5-7 fund clusters for others). The low premium of $6.30 limits absolute dollar risk while still providing meaningful leverage. IV at 41.0% is the lowest among all candidates and makes this the cheapest option on a volatility-adjusted basis. Volume is only 15 (lowest in dataset) and OI 636 is thin — this is the key liquidity risk. Spread at 3.2% is manageable. September expiry captures summer travel season peak data and back-to-school booking cycle, both natural catalysts for the thesis. Ranked 5th deliberately to reflect lower conviction and liquidity.
Stop Loss: -60% on option premium (~$3.78 per contract) given lower conviction |
Greeks: Available
MSFT
Microsoft Corporation
97.6/100
CONVICTION SCORE
CLUSTER
✅ +0.0% seit Filing – Signal noch frisch$421.92 → $421.92 · 3d ago
Investment Thesis
5-fund cluster across endowments (Harvard 10.46%), specialized allocators (Pershing Square 15.26%), and quant platforms (AQR, Viking Global) entering simultaneously indicates unified thesis on AI-as-platform-provider positioning. MSFT's Copilot/Azure integration and enterprise stickiness suggest lower risk profile than pure chip plays while maintaining upside to AI monetization cycles.
KEY BUYERS
Harvard Management Co, Pershing Square (Ackman), Tiger Global (Coleman), Viking Global (Halvorsen), AQR Capital (Asness)
RISK NOTE
Mega-cap tech already extensively covered and these positions may be consensus; stock has likely already captured much of the AI narrative given ubiquitous institutional ownership.
📈 RECOMMENDED OPTION TRADE
SYMBOL
MSFT260918C00430000
TYPE / STRIKE
CALL @ $430.0
MAX RISK / CONTRACT
$3005.0
PROFIT TARGET
+45-70% on option premium if MSFT moves to $465-480 (+10-13%) by September
Rationale: Strike at +1.5% OTM with Delta 0.53 is nearly ATM, appropriate for MSFT's lower beta and steadier AI monetization runway through Azure/Copilot. Critically, MSFT's IV at 31.6% is dramatically lower than semiconductor peers (NVDA 44.8%, AVGO 50%), making this the most attractively priced option on a premium-per-dollar-of-exposure basis. Volume 1292 and OI 5606 ensure good liquidity. Spread at 1.3% is among the tightest in the entire dataset. September expiry captures Q1 FY2027 earnings and multiple Azure growth data points.
Stop Loss: -50% on option premium (~$15.03 per contract) |
Greeks: Available
Portfolio Sizing Note
Suggested sizing reflects conviction tier weighting: NVDA and TSM at 30% of options budget each (7-fund and 5-fund elite clusters), MSFT and AVGO at 20% each (5-fund clusters with differentiated risk profiles), and BKNG at 10% (2-fund signal, liquidity concerns). Total options budget should represent no more than 3-5% of total portfolio value given the leveraged nature of these positions. The semiconductor cluster (NVDA+TSM+AVGO) represents correlated AI capex risk — consider reducing any single name if overall AI exposure exceeds comfort threshold. MSFT provides partial hedge as a lower-beta AI play. BKNG provides genuine sector diversification.
⚠️ DISCLAIMER: Options involve significant risk including total loss of premium paid. This analysis is based on 13F filings with an approximately 45-day reporting lag and real-time option prices that may differ materially at execution. Institutional positions may have already been reduced or reversed. IV levels and spreads are point-in-time estimates. Geopolitical events, earnings surprises, or macro shifts can cause rapid adverse moves. This is not investment advice. Consult a licensed financial advisor before trading.
Data limitations: 13F filings reflect long equity positions over $200K with up to 45-day delay.
Portfolio weights use long-only reported AUM (cash, shorts, bonds excluded – weights are systematically overstated).
Stock splits have been adjusted. Option prices are from Tradier at time of analysis and change constantly.
This report is generated automatically and does not constitute investment advice.
Generated automatically by SEC 13F Smart Money Analyzer ·
Data: SEC EDGAR + Tradier · Analysis: Claude AI
================================================
FILE: requirements.txt
================================================
anthropic>=0.25.0
requests>=2.31.0
yfinance>=0.2.37
holidays>=0.46
================================================
FILE: src/analyze_claude_round1.py
================================================
"""
analyze_claude_round1.py
Claude API – Round 1: Identify Top 5 investment candidates.
Uses claude-haiku (CLAUDE_MODEL_R1) – sufficient for screening and
~20× cheaper than Sonnet. Sonnet is reserved for Round 2 (precise
option selection where nuance matters more).
Improvements:
- CLAUDE_MODEL_R1 (Haiku) instead of Sonnet
- Multi-quarter build signals included in prompt
- Price-action staleness flags surfaced to Claude
- Exponential backoff retry
- Robust JSON extraction
"""
import json
import os
import re
import time
from datetime import date
import anthropic
from config import (
CLAUDE_MAX_TOKENS, CLAUDE_MODEL_R1, CLAUDE_RETRY_COUNT,
CLAUDE_RETRY_DELAY, DATA_DIR,
)
def load_scores(today_str: str) -> dict:
path = DATA_DIR / f"{today_str}_scores.json"
if not path.exists():
raise FileNotFoundError(f"Scores not found: {path}")
with open(path) as f:
return json.load(f)
def normalize_ticker(ticker: str) -> str:
return ticker.strip().upper().replace(".", "/")
def build_prompt(scores: dict) -> str:
today_str = scores["date"]
top20 = scores["top20"]
clusters = scores["clusters"]
mq_signals = scores.get("mq_signals", {})
positions_text = []
for i, agg in enumerate(top20, 1):
filer_summary = "; ".join(
f"{f['filer']} ({f['delta_type']}, "
f"Δ{f['delta_pct'] if f['delta_pct'] is not None else 'N/A'}%, "
f"port_wt={f['port_weight_pct']}%)"
for f in agg["filers"]
)
# Price-action context
price_chg = agg.get("price_change_since_filing_pct")
price_note = ""
if price_chg is not None:
if "PRICE_ACTION_STALE" in agg.get("flags", []):
price_note = f" ⚠️ ALREADY +{price_chg:.0f}% SINCE FILING – thesis may be priced in"
elif "PRICE_ACTION_WARNING" in agg.get("flags", []):
price_note = f" ⚡ +{price_chg:.0f}% since filing"
else:
price_note = f" (+{price_chg:.0f}% since filing)" if price_chg > 0 else f" ({price_chg:.0f}% since filing)"
# Multi-quarter context
mq_note = ""
mq = mq_signals.get(agg["ticker"])
if mq and mq["build_quarters"] >= 2:
mq_note = (
f"\n Multi-Quarter: {mq['build_quarters']} quarters of building"
f" | avg delta {mq['avg_delta_pct']}%"
f" | flags: {', '.join(mq['flags']) or 'none'}"
)
positions_text.append(
f"{i}. {agg['ticker']} ({agg['name']}){price_note}\n"
f" Score: {agg['conviction_score']}/100 | Filers: {agg['filer_count']} | "
f"Flags: {', '.join(agg['flags']) or 'none'}\n"
f" Cluster: {'YES – ' + str(agg['cluster_count']) + ' funds' if agg['cluster_count'] >= 3 else 'no'}\n"
f" Details: {filer_summary}{mq_note}\n"
)
cluster_text = ""
if clusters:
cluster_text = "\nCLUSTER SIGNALS (3+ funds buying same ticker):\n"
for ticker, filers in clusters.items():
cluster_text += f" {ticker}: {', '.join(filers)}\n"
return f"""You are an expert quantitative analyst specializing in 13F filing analysis and institutional investor tracking.
ANALYSIS DATE: {today_str}
DATA SOURCE: SEC 13F filings (latest available, up to 45-day lag)
IMPORTANT DISCLAIMER: 13F data reflects only US long equity positions >$200K.
Portfolio weights use long-only AUM (cash/shorts/bonds excluded → weights are systematically overstated).
Stock splits have been adjusted. Treat this as an idea generator, not a buy signal.
IMPORTANT – PRICE ACTION: Positions marked ⚠️ ALREADY +X% SINCE FILING have potentially
already played out. Strong preference for fresh ideas that have NOT run significantly yet.
TOP 20 CONVICTION SCORES (normalized 0-100):
{''.join(positions_text)}
{cluster_text}
YOUR TASK:
Analyze the above data and identify the TOP 5 stocks with the strongest institutional conviction signals
that have NOT already fully played out in price.
Consider in priority order:
1. Multi-quarter building (3+ quarters of consistent accumulation = strongest signal)
2. Cluster signals (multiple top funds buying simultaneously)
3. Fresh entries that haven't run >15% since the filing date
4. Conviction Score magnitude
5. Quality of the buying funds (university endowments > hedge funds for long-term thesis)
6. Position type flags: HIGH_CONVICTION (>3% of portfolio), NEW_POSITION, AGGRESSIVE_ADD
Explicitly DOWNWEIGHT stocks with PRICE_ACTION_STALE flag – the thesis is likely priced in.
OUTPUT FORMAT (respond ONLY with valid JSON, no markdown, no explanation):
{{
"analysis_date": "{today_str}",
"market_context": "2-3 sentence summary of current market environment relevant to these picks",
"top5": [
{{
"rank": 1,
"ticker": "NORMALIZED_TICKER",
"company_name": "Full Company Name",
"conviction_score": 87.5,
"thesis": "2-3 sentence investment thesis explaining WHY this is a strong signal",
"key_buyers": ["Fund Name 1", "Fund Name 2"],
"cluster_signal": true,
"multi_quarter_build": false,
"primary_flag": "HIGH_CONVICTION|NEW_POSITION|AGGRESSIVE_ADD|CLUSTER|MULTI_QUARTER_BUILD",
"risk_factors": "1-2 sentence note on key risks or the 45-day data lag impact",
"direction": "BULLISH"
}}
],
"disclaimer": "This analysis is based on delayed 13F data and is for informational purposes only, not investment advice."
}}"""
def call_claude_with_retry(prompt: str) -> str:
client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
for attempt in range(1, CLAUDE_RETRY_COUNT + 1):
try:
response = client.messages.create(
model=CLAUDE_MODEL_R1,
max_tokens=CLAUDE_MAX_TOKENS,
system=(
"You are a quantitative analyst. You respond ONLY with valid JSON. "
"Never include markdown code fences, preamble, or explanation. "
"Your entire response must be parseable by json.loads()."
),
messages=[{"role": "user", "content": prompt}],
)
return response.content[0].text
except anthropic.RateLimitError:
wait = CLAUDE_RETRY_DELAY * (2 ** (attempt - 1))
print(f" ⏳ Rate limit hit. Waiting {wait}s (attempt {attempt}/{CLAUDE_RETRY_COUNT})")
time.sleep(wait)
except anthropic.APIError as e:
wait = CLAUDE_RETRY_DELAY * attempt
print(f" ⚠️ API error (attempt {attempt}): {e}. Retrying in {wait}s...")
time.sleep(wait)
raise RuntimeError(f"Claude API failed after {CLAUDE_RETRY_COUNT} attempts")
def parse_claude_response(raw: str) -> dict:
cleaned = re.sub(r"```(?:json)?", "", raw).strip()
try:
return json.loads(cleaned)
except json.JSONDecodeError as e:
match = re.search(r"\{.*\}", cleaned, re.DOTALL)
if match:
return json.loads(match.group())
raise ValueError(f"Could not parse Claude response as JSON: {e}\n\nRaw: {raw[:500]}")
def run():
today_str = date.today().isoformat()
print(f"\n{'='*60}")
print(f"Claude Round 1 (Haiku) – {today_str}")
print(f"{'='*60}")
print(f" Model: {CLAUDE_MODEL_R1}")
scores = load_scores(today_str)
prompt = build_prompt(scores)
print(f"📤 Sending top {len(scores['top20'])} scored positions to Claude Haiku...")
raw_response = call_claude_with_retry(prompt)
result = parse_claude_response(raw_response)
for stock in result.get("top5", []):
stock["ticker"] = normalize_ticker(stock.get("ticker", ""))
print(f"✅ Claude identified top 5:")
for stock in result.get("top5", []):
print(f" {stock['rank']}. {stock['ticker']} – {stock['thesis'][:60]}...")
output_path = DATA_DIR / f"{today_str}_claude_round1.json"
with open(output_path, "w") as f:
json.dump(result, f, indent=2)
print(f"💾 Saved to {output_path}")
if __name__ == "__main__":
run()
================================================
FILE: src/analyze_claude_round2.py
================================================
"""
analyze_claude_round2.py
Claude API – Round 2: Select the best specific options from real Tradier data.
Uses claude-sonnet (CLAUDE_MODEL_R2) – precision matters here.
Claude receives the top 5 theses + real option chains and picks the
single best contract per stock, with explicit reasoning on strike,
expiry, IV, and liquidity.
Improvements:
- CLAUDE_MODEL_R2 (Sonnet) explicitly
- Structured JSON output enforced
- Retry with exponential backoff
- Validates that report is non-empty before saving
"""
import json
import os
import re
import time
from datetime import date
import anthropic
from config import (
CLAUDE_MAX_TOKENS, CLAUDE_MODEL_R2, CLAUDE_RETRY_COUNT,
CLAUDE_RETRY_DELAY, DATA_DIR,
)
def load_round1(today_str: str) -> dict:
path = DATA_DIR / f"{today_str}_claude_round1.json"
if not path.exists():
raise FileNotFoundError(f"Claude Round 1 results not found: {path}")
with open(path) as f:
return json.load(f)
def load_options(today_str: str) -> dict:
path = DATA_DIR / f"{today_str}_options.json"
if not path.exists():
raise FileNotFoundError(f"Options data not found: {path}")
with open(path) as f:
return json.load(f)
def format_options_for_prompt(ticker: str, opt_data: dict) -> str:
"""Formats option candidates concisely for the prompt, including live stock price."""
options = opt_data.get("options", [])
current_price = opt_data.get("current_price")
change_pct = opt_data.get("change_pct")
direction = opt_data.get("direction", "BULLISH")
price_str = f"${current_price}" if current_price else "n/a"
change_str = f"{change_pct:+.2f}%" if change_pct is not None else "n/a"
if not options:
return f"\n{ticker} — Current: {price_str} ({change_str}) | No options data available\n"
lines = [f"\n{ticker} — Current price: {price_str} ({change_str} today) | Direction: {direction}"]
lines.append(f"{'Symbol':<22}{'Strike':<10}{'vs Spot':<10}{'Expiry':<14}{'Mid':<8}"
f"{'Sprd%':<8}{'Vol':<8}{'OI':<8}{'Delta':<8}{'IV':<8}")
lines.append("─" * 104)
for opt in options[:8]:
strike = opt.get("strike")
delta_str = f"{opt['delta']:.2f}" if opt.get("delta") else "n/a"
iv_str = f"{float(opt['implied_volatility']):.1%}" if opt.get("implied_volatility") else "n/a"
mid_str = f"${opt['mid']}" if opt.get("mid") else "n/a"
spread_str = f"{opt['spread_pct']}%" if opt.get("spread_pct") is not None else "n/a"
# Show how far the strike is from current price
if strike and current_price:
vs_spot = f"{((float(strike) / float(current_price)) - 1) * 100:+.1f}%"
else:
vs_spot = "n/a"
lines.append(
f"{str(opt.get('symbol', '')):<22}"
f"{str(strike or ''):<10}"
f"{vs_spot:<10}"
f"{str(opt.get('expiration_date', '')):<14}"
f"{mid_str:<8}"
f"{spread_str:<8}"
f"{str(opt.get('volume', '')):<8}"
f"{str(opt.get('open_interest', '')):<8}"
f"{delta_str:<8}"
f"{iv_str:<8}"
)
if not opt.get("greeks_available"):
lines.append(" ⚠️ Greeks unavailable (pre-market snapshot)")
return "\n".join(lines)
def build_round2_prompt(r1: dict, options_data: dict) -> str:
today_str = r1.get("analysis_date", date.today().isoformat())
# Build thesis summary
theses = []
for stock in r1.get("top5", []):
theses.append(
f"#{stock['rank']} {stock['ticker']} – {stock['company_name']}\n"
f" Thesis: {stock['thesis']}\n"
f" Key buyers: {', '.join(stock.get('key_buyers', []))}\n"
f" Risk: {stock.get('risk_factors', '')}"
)
# Build options tables
option_tables = []
for ticker, opt_data in options_data.get("options", {}).items():
option_tables.append(format_options_for_prompt(ticker, opt_data))
return f"""You are an expert options strategist with deep knowledge of institutional investor behavior.
ANALYSIS DATE: {today_str}
TASK: For each of the 5 stocks below, select the SINGLE BEST option based on the provided real-market data.
INVESTMENT THESES (from 13F conviction analysis):
{''.join(theses)}
REAL OPTIONS DATA FROM TRADIER:
{''.join(option_tables)}
OPTION SELECTION CRITERIA:
1. Strike selection: Use the "vs Spot" column to assess moneyness. For BULLISH plays, prefer
slightly OTM (+2% to +8% above current price, Delta 0.35-0.50) for leverage with reasonable
probability of profit. ATM (Delta 0.45-0.55) for higher conviction plays.
2. Expiry: 3-6 months allows time for institutional thesis to play out (13F data is already
~45 days old, so add that to your horizon).
3. IV consideration: Avoid buying options with unusually high IV (paying too much premium).
Compare IV levels across strikes and expiries in the table.
4. Liquidity: Prefer options with volume >200, OI >500, and spread% <10%. Spread% is shown
in the table — wide spreads (>12%) hurt entry/exit significantly.
5. Current price context: The live stock price is shown above each options table. Use it to
judge whether the thesis has already played out (stock already up a lot since 13F filing)
or still has room to run.
OUTPUT FORMAT (respond ONLY with valid JSON, no markdown fences):
{{
"analysis_date": "{today_str}",
"options_recommendations": [
{{
"rank": 1,
"stock_ticker": "TICKER",
"company_name": "Full Name",
"option_symbol": "EXACT_OPTION_SYMBOL_FROM_DATA",
"option_type": "CALL",
"strike": 150.0,
"expiration": "YYYY-MM-DD",
"entry_price_mid": 5.50,
"max_risk_per_contract": 550.0,
"investment_thesis_link": "1-2 sentences linking the 13F signal to this specific option choice",
"option_rationale": "Why THIS strike and expiry specifically – delta, IV, time horizon reasoning",
"profit_target": "e.g. +50-80% on option premium if stock moves +10-15%",
"stop_loss": "e.g. -50% on option premium",
"key_risk": "1 sentence on the main risk for this trade",
"greeks_note": "Available|Pre-market estimate only"
}}
],
"portfolio_note": "Brief note on sizing – e.g. equal weight vs. high conviction weighting",
"disclaimer": "Options involve significant risk. This is based on delayed 13F data and real-time option prices may differ. Not investment advice."
}}"""
def call_claude_with_retry(prompt: str) -> str:
client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
for attempt in range(1, CLAUDE_RETRY_COUNT + 1):
try:
response = client.messages.create(
model=CLAUDE_MODEL_R2,
max_tokens=CLAUDE_MAX_TOKENS,
system=(
"You are an expert options strategist. Respond ONLY with valid JSON. "
"No markdown, no code fences, no preamble. "
"Your entire response must be parseable by json.loads()."
),
messages=[{"role": "user", "content": prompt}],
)
return response.content[0].text
except anthropic.RateLimitError:
wait = CLAUDE_RETRY_DELAY * (2 ** (attempt - 1))
print(f" ⏳ Rate limit. Waiting {wait}s (attempt {attempt}/{CLAUDE_RETRY_COUNT})")
time.sleep(wait)
except anthropic.APIError as e:
wait = CLAUDE_RETRY_DELAY * attempt
print(f" ⚠️ API error (attempt {attempt}): {e}. Retry in {wait}s...")
time.sleep(wait)
raise RuntimeError(f"Claude API failed after {CLAUDE_RETRY_COUNT} attempts")
def parse_response(raw: str) -> dict:
cleaned = re.sub(r"```(?:json)?", "", raw).strip()
try:
return json.loads(cleaned)
except json.JSONDecodeError:
match = re.search(r"\{.*\}", cleaned, re.DOTALL)
if match:
return json.loads(match.group())
raise ValueError(f"Cannot parse Claude Round 2 response:\n{raw[:500]}")
def validate_result(result: dict) -> bool:
"""
R-14 Fix: Ensure the result is substantive before saving.
Returns False if the result appears empty or malformed.
"""
recs = result.get("options_recommendations", [])
if not recs:
print(" ⚠️ VALIDATION FAILED: No recommendations in Claude response")
return False
if len(recs) < 3:
print(f" ⚠️ VALIDATION WARNING: Only {len(recs)} recommendations (expected 5)")
for rec in recs:
if not rec.get("option_symbol") or not rec.get("stock_ticker"):
print(f" ⚠️ VALIDATION FAILED: Missing ticker or symbol in recommendation: {rec}")
return False
return True
def run():
today_str = date.today().isoformat()
print(f"\n{'='*60}")
print(f"Claude Analysis Round 2 – {today_str}")
print(f"{'='*60}")
r1 = load_round1(today_str)
options_data = load_options(today_str)
prompt = build_round2_prompt(r1, options_data)
print(f"📤 Sending real options data for {len(r1.get('top5', []))} stocks to Claude...")
raw_response = call_claude_with_retry(prompt)
result = parse_response(raw_response)
if not validate_result(result):
raise RuntimeError("Claude Round 2 result failed validation – aborting report")
print(f"✅ Claude selected {len(result.get('options_recommendations', []))} option trades:")
for rec in result.get("options_recommendations", []):
mid = rec.get("entry_price_mid", "?")
print(f" #{rec['rank']} {rec['stock_ticker']} → {rec['option_symbol']} "
f"@ ${mid} | {rec.get('profit_target', '')}")
# Enrich round1_top5 with post-filing price performance and per-filer detail
# from scores.json so the report can show price movement and buyer breakdown.
top5 = r1.get("top5", [])
try:
scores_path = DATA_DIR / f"{today_str}_scores.json"
with open(scores_path) as sf:
scores = json.load(sf)
aggregated = scores.get("aggregated", [])
perf_by_ticker = {agg["ticker"]: agg.get("post_filing_perf", {}) for agg in aggregated}
filers_by_ticker = {agg["ticker"]: agg.get("filers", []) for agg in aggregated}
for stock in top5:
t = stock.get("ticker", "")
stock["post_filing_perf"] = perf_by_ticker.get(t, {})
stock["filer_details"] = filers_by_ticker.get(t, [])
enriched = sum(1 for s in top5 if s.get("post_filing_perf"))
print(f" ✅ Enriched {enriched}/{len(top5)} stocks with post-filing perf + filer details")
except Exception as e:
print(f" ⚠️ Could not enrich with post-filing perf / filer details: {e}")
# Merge Round 1 and Round 2 into final analysis file
final = {
"date": today_str,
"round1_top5": top5,
"market_context": r1.get("market_context", ""),
"options_recs": result.get("options_recommendations", []),
"portfolio_note": result.get("portfolio_note", ""),
"disclaimer": result.get("disclaimer", ""),
}
output_path = DATA_DIR / f"{today_str}_final_analysis.json"
with open(output_path, "w") as f:
json.dump(final, f, indent=2)
print(f"💾 Final analysis saved to {output_path}")
if __name__ == "__main__":
run()
================================================
FILE: src/backtest.py
================================================
"""
backtest.py
Tracks historical performance of past recommendations.
For each past final_analysis.json, checks what the underlying stock
did 90 and 180 days after the report date. This is the only way to
know if the system generates alpha or just looks good.
Saved to data/holdings/{today}_backtest.json and embedded in the report.
"""
import json
from datetime import date, timedelta
from pathlib import Path
try:
import yfinance as yf
YF_AVAILABLE = True
except ImportError:
YF_AVAILABLE = False
from config import DATA_DIR
def load_all_analyses() -> list[dict]:
files = sorted(DATA_DIR.glob("*_final_analysis.json"))
results = []
for f in files:
try:
with open(f) as fh:
results.append(json.load(fh))
except (json.JSONDecodeError, OSError):
continue
return results
def _yf_ticker(ticker: str) -> str:
"""Convert Tradier-style tickers to yfinance format. BRK/B → BRK-B."""
return ticker.replace("/", "-")
def check_stock_performance(ticker: str, signal_date_str: str) -> dict:
"""
Downloads price history for ticker starting from signal_date.
Returns price at signal, +90d, +180d, and % returns.
"""
if not YF_AVAILABLE:
return {"error": "yfinance_not_installed"}
try:
signal_date = date.fromisoformat(signal_date_str)
# Don't request data past today
end_date = min(signal_date + timedelta(days=200), date.today())
if end_date <= signal_date:
return {"status_d90": "pending", "status_d180": "pending"}
hist = yf.Ticker(_yf_ticker(ticker)).history(
start=signal_date.isoformat(),
end=end_date.isoformat(),
)
if hist.empty:
return {"error": "no_price_data"}
price_start = float(hist["Close"].iloc[0])
result: dict = {
"signal_date": signal_date_str,
"price_at_signal": round(price_start, 2),
}
for days, label in [(90, "d90"), (180, "d180")]:
target = signal_date + timedelta(days=days)
if target > date.today():
result[f"price_{label}"] = None
result[f"return_{label}_pct"] = None
result[f"status_{label}"] = "pending"
else:
future = hist[hist.index.date >= target]
if not future.empty:
p = float(future["Close"].iloc[0])
ret = ((p - price_start) / price_start) * 100
result[f"price_{label}"] = round(p, 2)
result[f"return_{label}_pct"] = round(ret, 1)
result[f"status_{label}"] = "win" if ret > 0 else "loss"
else:
result[f"price_{label}"] = None
result[f"return_{label}_pct"] = None
result[f"status_{label}"] = "no_data"
return result
except Exception as e:
return {"error": str(e)}
def run() -> dict:
today_str = date.today().isoformat()
print(f"\n{'='*60}")
print(f"Backtesting Engine – {today_str}")
print(f"{'='*60}")
analyses = load_all_analyses()
if not analyses:
print("No past analyses found. Skipping backtest.")
return {"summary": {}, "results": []}
rows = []
for analysis in analyses:
report_date = analysis.get("date", "")
for stock in analysis.get("round1_top5", []):
ticker = stock.get("ticker", "")
if not ticker:
continue
print(f" 📊 {ticker} @ {report_date}...", end=" ", flush=True)
perf = check_stock_performance(ticker, report_date)
ret90 = perf.get("return_d90_pct")
print(f"{f'+{ret90}%' if ret90 and ret90 > 0 else (f'{ret90}%' if ret90 is not None else perf.get('status_d90', '?'))}")
rows.append({
"report_date": report_date,
"ticker": ticker,
"company": stock.get("company_name", ""),
"conviction_score": stock.get("conviction_score"),
"primary_flag": stock.get("primary_flag", ""),
**perf,
})
# Summary statistics (only on completed, non-error rows)
done_90 = [r for r in rows if r.get("status_d90") in ("win", "loss")]
done_180 = [r for r in rows if r.get("status_d180") in ("win", "loss")]
def _win_rate(subset, key):
if not subset:
return None
return round(sum(1 for r in subset if r.get(key) == "win") / len(subset) * 100, 1)
def _avg_ret(subset, key):
vals = [r[key] for r in subset if r.get(key) is not None]
return round(sum(vals) / len(vals), 1) if vals else None
summary = {
"generated_at": today_str,
"total_signals": len(rows),
"completed_90d": len(done_90),
"completed_180d": len(done_180),
"win_rate_90d_pct": _win_rate(done_90, "status_d90"),
"win_rate_180d_pct": _win_rate(done_180, "status_d180"),
"avg_return_90d_pct": _avg_ret(done_90, "return_d90_pct"),
"avg_return_180d_pct":_avg_ret(done_180, "return_d180_pct"),
}
output = {"summary": summary, "results": rows}
out_path = DATA_DIR / f"{today_str}_backtest.json"
with open(out_path, "w") as f:
json.dump(output, f, indent=2, default=str)
print(f"\n{'─'*40}")
print(f"BACKTEST SUMMARY ({len(rows)} signals tracked)")
if summary["win_rate_90d_pct"] is not None:
print(f" 90d win rate : {summary['win_rate_90d_pct']}% "
f"(avg {summary['avg_return_90d_pct']:+.1f}%)")
if summary["win_rate_180d_pct"] is not None:
print(f" 180d win rate : {summary['win_rate_180d_pct']}% "
f"(avg {summary['avg_return_180d_pct']:+.1f}%)")
print(f"✅ Saved to {out_path}")
return output
if __name__ == "__main__":
run()
================================================
FILE: src/config.py
================================================
"""
config.py
Central configuration for SEC 13F Smart Money Analyzer.
All CIKs, thresholds, and API endpoints defined here.
"""
from pathlib import Path
# ── Directory layout ──────────────────────────────────────────────────────────
BASE_DIR = Path(__file__).parent.parent
DATA_DIR = BASE_DIR / "data" / "holdings"
REPORTS_DIR = BASE_DIR / "reports"
DATA_DIR.mkdir(parents=True, exist_ok=True)
REPORTS_DIR.mkdir(parents=True, exist_ok=True)
# ── Filer registry ────────────────────────────────────────────────────────────
# Format: { "display_name": "CIK_padded_to_10_digits" }
FILERS = {
"Situational Awareness LP": "0002045724",
"Yale University": "0000938582",
"Gates Foundation Trust": "0001166559",
"Harvard Management Co": "0001082621",
"Brown University": "0001664741",
"Duke University": "0001439873",
"TCI Fund (Chris Hohn)": "0001649339",
"Pershing Square (Ackman)": "0001336528",
"Tiger Global (Coleman)": "0001167483",
"Coatue (Laffont)": "0001766502",
"D1 Capital (Sundheim)": "0001747057",
"Viking Global (Halvorsen)": "0001103804",
"AQR Capital (Asness)": "0001167557",
}
# ── Filer quality tiers ───────────────────────────────────────────────────────
# University endowments: long-horizon, fundamental → higher weight
# Growth hedge funds: more momentum-driven → lower weight
# These multipliers are applied to raw_score in scoring.py
FILER_QUALITY: dict[str, float] = {
"Yale University": 1.3,
"Harvard Management Co": 1.3,
"Gates Foundation Trust": 1.3,
"Brown University": 1.2,
"Duke University": 1.2,
"TCI Fund (Chris Hohn)": 1.2,
"Viking Global (Halvorsen)": 1.1,
"AQR Capital (Asness)": 1.0,
"Pershing Square (Ackman)": 1.0,
"Tiger Global (Coleman)": 0.9,
"Coatue (Laffont)": 0.9,
"D1 Capital (Sundheim)": 0.9,
"Situational Awareness LP": 0.8,
}
# ── SEC EDGAR endpoints ───────────────────────────────────────────────────────
EDGAR_SUBMISSIONS_URL = "https://data.sec.gov/submissions/CIK{cik}.json"
EDGAR_ARCHIVES_URL = "https://www.sec.gov/Archives/edgar/data/{cik_int}/{accession_dashes}/{filename}"
SEC_HEADERS = {
"User-Agent": "SmartMoneyAnalyzer research@example.com", # SEC requires this
"Accept-Encoding": "gzip, deflate",
}
SEC_RATE_LIMIT_SLEEP = 0.15 # seconds between requests (max 10/s allowed)
# ── OpenFIGI (CUSIP → Ticker mapping) ────────────────────────────────────────
OPENFIGI_URL = "https://api.openfigi.com/v3/mapping"
OPENFIGI_BATCH = 100 # up to 100 with API key (openfigi.com), 10 without
OPENFIGI_API_KEY = "" # optional – set as GitHub Secret OPENFIGI_API_KEY for higher limits
# ── Scoring weights ───────────────────────────────────────────────────────────
WEIGHT_PORTFOLIO_PCT = 0.20 # how large the position is in the portfolio
WEIGHT_DELTA_PCT = 0.20 # how aggressively the manager bought
# ── Scoring thresholds ────────────────────────────────────────────────────────
MIN_PORTFOLIO_WEIGHT_PCT = 0.5 # ignore positions < 0.5% of portfolio
HIGH_CONVICTION_TOP_N = 10 # "top 10" threshold for new position flag
HIGH_CONVICTION_MIN_PCT = 3.0 # new position >= 3% = HIGH CONVICTION flag
CLUSTER_MIN_FUNDS = 2 # 2+ funds buying = cluster signal
CLUSTER_BONUS_MULTIPLIER = 3.0 # strong bonus: 6-fund cluster >> 1-fund
DOUBLE_DOWN_MIN_DELTA = 20.0 # +20% shares while price fell = double-down
# ── Price-action staleness check ─────────────────────────────────────────────
# Compares current price to price at filing date (via yfinance).
# Prevents recommending stocks that have already fully played out.
PRICE_ACTION_WARN_PCT = 15.0 # add WARNING flag if up >15% since filing
PRICE_ACTION_DOWNGRADE_PCT = 25.0 # halve the score if up >25% since filing
# ── Multi-quarter conviction tracking ────────────────────────────────────────
MULTI_QUARTER_MAX = 8 # look back up to 8 quarters of history
MULTI_QUARTER_BUILD_MIN = 3 # 3+ consecutive build quarters = strong signal
MULTI_QUARTER_BONUS = 1.5 # score multiplier for confirmed multi-quarter builds
# ── Tradier API ───────────────────────────────────────────────────────────────
TRADIER_BASE_URL = "https://api.tradier.com/v1" # Live account
# TRADIER_BASE_URL = "https://sandbox.tradier.com/v1" # Paper account
OPTION_MIN_VOLUME = 300 # was 100 – stricter liquidity requirement
OPTION_MAX_SPREAD_PCT = 8.0 # skip options with bid-ask spread > 8% of mid
OPTION_DELTA_MIN = 0.30
OPTION_DELTA_MAX = 0.70
OPTION_MIN_DAYS = 90
OPTION_MAX_DAYS = 180
OPTION_MAX_IV = 0.70 # skip options with IV > 70% (overpriced premium)
# ── Claude API ────────────────────────────────────────────────────────────────
# Round 1 (top-20 screening): Haiku is sufficient and ~20× cheaper than Sonnet
# Round 2 (precise option selection): Sonnet for nuanced financial reasoning
CLAUDE_MODEL_R1 = "claude-haiku-4-5-20251001"
CLAUDE_MODEL_R2 = "claude-sonnet-4-6"
CLAUDE_MODEL = CLAUDE_MODEL_R2 # backward-compat alias
CLAUDE_MAX_TOKENS = 4096
CLAUDE_RETRY_COUNT = 3
CLAUDE_RETRY_DELAY = 5 # seconds
# ── Gmail ─────────────────────────────────────────────────────────────────────
GMAIL_SMTP_HOST = "smtp.gmail.com"
GMAIL_SMTP_PORT = 587
REPORT_SUBJECT = "📊 SEC 13F Smart Money Report – {date}"
================================================
FILE: src/date_check.py
================================================
"""
date_check.py
Determines if today is a valid SEC 13F analysis run date.
Target dates: 16th of May, Aug, Nov, Feb (Berlin time)
Weekend/holiday → next business day
Writes GitHub Actions output: should_run=true/false
"""
import os
import sys
from datetime import date, timedelta
import holidays
TARGET_MONTHS = {2, 5, 8, 11}
TARGET_DAY = 16
# German public holidays (federal-level) as fallback
# SEC is a US system – EDGAR is open every day – so we only skip
# weekends. German holidays are NOT a reason to skip, but the
# cron only fires 14-20th of target months so this is future-proof.
DE_HOLIDAYS = holidays.Germany(years=range(2024, 2035))
def next_business_day(d: date) -> date:
"""Advance d until it falls on Mon-Fri (weekends only, not holidays)."""
while d.weekday() >= 5: # 5=Sat, 6=Sun
d += timedelta(days=1)
return d
def get_expected_run_date(ref: date) -> date:
"""
For the given reference date's month/year, return the actual
run date (16th of that month → adjusted for weekends).
Only valid if ref.month is in TARGET_MONTHS.
"""
target = date(ref.year, ref.month, TARGET_DAY)
return next_business_day(target)
def should_run_today(today: date, force: bool = False, target_override: str = "") -> bool:
if force:
print(f"FORCE_RUN=true → running regardless of date ({today})")
return True
if target_override:
try:
override = date.fromisoformat(target_override)
result = today == override
print(f"Target override {override}: today={today}, match={result}")
return result
except ValueError:
print(f"Invalid TARGET_DATE '{target_override}', ignoring.")
if today.month not in TARGET_MONTHS:
print(f"Month {today.month} is not a target month {TARGET_MONTHS}. Skip.")
return False
expected = get_expected_run_date(today)
result = today == expected
print(f"Expected run date for {today.year}-{today.month:02d}: {expected}. Today: {today}. Run: {result}")
return result
def write_github_output(key: str, value: str):
"""Write to GITHUB_OUTPUT file (new Actions syntax)."""
output_file = os.environ.get("GITHUB_OUTPUT", "")
if output_file:
with open(output_file, "a") as f:
f.write(f"{key}={value}\n")
else:
# Local testing fallback
print(f"[local] {key}={value}")
if __name__ == "__main__":
today = date.today()
force = os.environ.get("FORCE_RUN", "false").lower() == "true"
target_override = os.environ.get("TARGET_DATE", "").strip()
run = should_run_today(today, force=force, target_override=target_override)
write_github_output("should_run", "true" if run else "false")
if not run:
print("Not a run date. Pipeline will stop here.")
sys.exit(0)
print(f"✅ Run date confirmed: {today}")
================================================
FILE: src/fetch_filings.py
================================================
"""
fetch_filings.py
Fetches the latest 13F-HR filings for all configured filers from SEC EDGAR.
Uses the EDGAR full-text search API to find the infotable XML directly,
bypassing the unreliable index.json approach.
"""
import json
import time
import xml.etree.ElementTree as ET
from datetime import date, datetime
from pathlib import Path
import requests
import os
from config import (
DATA_DIR, FILERS, OPENFIGI_API_KEY, OPENFIGI_BATCH, OPENFIGI_URL,
SEC_HEADERS, SEC_RATE_LIMIT_SLEEP,
)
def _sleep():
time.sleep(SEC_RATE_LIMIT_SLEEP)
def edgar_get(url: str) -> requests.Response:
_sleep()
resp = requests.get(url, headers=SEC_HEADERS, timeout=30)
resp.raise_for_status()
return resp
# ── Step 1: Get latest 13F filing metadata ────────────────────────────────────
def get_latest_13f_filing(cik: str) -> dict | None:
url = f"https://data.sec.gov/submissions/CIK{cik}.json"
try:
data = edgar_get(url).json()
except Exception as e:
print(f" ⚠️ Could not fetch submissions for CIK {cik}: {e}")
return None
filings = data.get("filings", {}).get("recent", {})
forms = filings.get("form", [])
accessions = filings.get("accessionNumber", [])
dates = filings.get("filingDate", [])
primary_docs = filings.get("primaryDocument", [])
report_dates = filings.get("reportDate", [])
for i, form in enumerate(forms):
if form in ("13F-HR", "13F-HR/A"):
return {
"cik": cik,
"accessionNumber": accessions[i],
"filingDate": dates[i],
# reportDate = quarter-end (period of report), e.g. 2024-12-31.
# Always earlier than filingDate (which can be up to 45 days later).
# Use this as the price-comparison anchor so we measure from
# when the manager actually held the position, not when they disclosed it.
"reportDate": report_dates[i] if i < len(report_dates) else dates[i],
"form": form,
"isAmendment": form == "13F-HR/A",
"primaryDocument": primary_docs[i] if i < len(primary_docs) else "",
}
print(f" ℹ️ No 13F-HR found for CIK {cik}")
return None
# ── Step 2: Get all files in filing and find infotable ────────────────────────
def get_filing_files(cik: str, accession: str) -> list[dict]:
"""
Fetches the list of files in a filing using the EDGAR submissions API.
Returns list of {name, type} dicts.
"""
cik_int = int(cik)
acc_nodash = accession.replace("-", "")
# Try index.json (directory listing)
url = f"https://www.sec.gov/Archives/edgar/data/{cik_int}/{acc_nodash}/index.json"
try:
resp = edgar_get(url)
data = resp.json()
items = data.get("directory", {}).get("item", [])
if isinstance(items, dict):
items = [items]
if items:
print(f" Files: {[i.get('name','') for i in items]}")
return items
except Exception as e:
print(f" ⚠️ index.json failed: {e}")
# Fallback: try the EDGAR filing index page as text
url2 = f"https://www.sec.gov/Archives/edgar/data/{cik_int}/{acc_nodash}/{accession}-index.htm"
try:
resp2 = edgar_get(url2)
# Parse filenames from HTML
import re
names = re.findall(r'href="([^"]+\.xml)"', resp2.text, re.IGNORECASE)
items = [{"name": n.split("/")[-1]} for n in names]
if items:
print(f" Files (from htm): {[i['name'] for i in items]}")
return items
except Exception as e:
print(f" ⚠️ index.htm also failed: {e}")
return []
def find_infotable_filename(items: list[dict]) -> str | None:
"""Find the information table XML from list of filing files."""
# Pass 1: name contains 'informationtable'
for item in items:
name = item.get("name", "").lower()
if "informationtable" in name and name.endswith(".xml"):
return item["name"]
# Pass 2: any xml that isn't the primary/cover/summary doc
skip_keywords = ["primary", "cover", "summary", "header", "form13f"]
for item in items:
name = item.get("name", "").lower()
if name.endswith(".xml") and not any(k in name for k in skip_keywords):
return item["name"]
# Pass 3: second xml file (first is usually primary doc)
xml_files = [i["name"] for i in items if i.get("name","").lower().endswith(".xml")]
if len(xml_files) >= 2:
return xml_files[1]
if len(xml_files) == 1:
return xml_files[0]
return None
def download_infotable(filing_meta: dict) -> str | None:
cik_int = int(filing_meta["cik"])
accession = filing_meta["accessionNumber"]
acc_nodash = accession.replace("-", "")
items = get_filing_files(filing_meta["cik"], accession)
infotable_filename = find_infotable_filename(items)
if not infotable_filename:
# Last resort: try common filename patterns directly
candidates = [
"informationtable.xml",
f"{acc_nodash}-informationtable.xml",
"form13fInfoTable.xml",
"infotable.xml",
]
for candidate in candidates:
url = f"https://www.sec.gov/Archives/edgar/data/{cik_int}/{acc_nodash}/{candidate}"
try:
resp = edgar_get(url)
if resp.status_code == 200 and "<" in resp.text:
print(f" ✅ Found via direct guess: {candidate}")
return resp.text
except Exception:
continue
print(f" ⚠️ Could not find infotable XML for {accession}")
return None
xml_url = f"https://www.sec.gov/Archives/edgar/data/{cik_int}/{acc_nodash}/{infotable_filename}"
try:
xml_text = edgar_get(xml_url).text
print(f" ✅ Downloaded: {infotable_filename} ({len(xml_text)} chars)")
return xml_text
except Exception as e:
print(f" ⚠️ Could not download {infotable_filename}: {e}")
return None
# ── Step 3: Parse XML holdings ────────────────────────────────────────────────
def parse_infotable(xml_text: str) -> list[dict]:
try:
root = ET.fromstring(xml_text)
except ET.ParseError as e:
print(f" ⚠️ XML parse error: {e}")
return []
tag = root.tag
ns_uri = ""
if tag.startswith("{"):
ns_uri = tag[1:tag.index("}")]
ns = {"ns": ns_uri} if ns_uri else {}
prefix = "ns:" if ns_uri else ""
holdings = []
for entry in root.findall(f".//{prefix}infoTable", ns):
def _t(tag_name):
el = entry.find(f"{prefix}{tag_name}", ns)
return el.text.strip() if el is not None and el.text else ""
try:
value_raw = _t("value")
shares_raw = _t("sshPrnamt")
holding = {
"cusip": _t("cusip"),
"nameOfIssuer": _t("nameOfIssuer"),
"titleOfClass": _t("titleOfClass"),
"value_usd_thousands": int(value_raw.replace(",", "")) if value_raw else 0,
"shares": int(shares_raw.replace(",", "")) if shares_raw else 0,
"sshPrnamtType": _t("sshPrnamtType"),
"putCall": _t("putCall") or None,
"investmentDiscretion":_t("investmentDiscretion"),
}
if holding["cusip"]:
holdings.append(holding)
except (ValueError, AttributeError) as e:
continue
return holdings
# ── Step 4: CUSIP → Ticker via OpenFIGI ──────────────────────────────────────
def _openfigi_headers() -> dict:
"""Returns headers for OpenFIGI. Uses API key from env if available."""
api_key = os.environ.get("OPENFIGI_API_KEY", OPENFIGI_API_KEY).strip()
h = {"Content-Type": "application/json"}
if api_key:
h["X-OPENFIGI-APIKEY"] = api_key
return h
def map_cusips_to_tickers(cusips: list[str]) -> dict[str, str]:
mapping = {}
if not cusips:
return mapping
headers = _openfigi_headers()
unique_cusips = list(set(cusips))
total = len(unique_cusips)
for i in range(0, total, OPENFIGI_BATCH):
batch = unique_cusips[i:i + OPENFIGI_BATCH]
payload = [{"idType": "ID_CUSIP", "idValue": c} for c in batch]
try:
resp = requests.post(OPENFIGI_URL, json=payload, headers=headers, timeout=20)
if resp.status_code == 429:
time.sleep(60)
resp = requests.post(OPENFIGI_URL, json=payload, headers=headers, timeout=20)
if resp.status_code == 413:
print(f" ⚠️ OpenFIGI 413 – batch too large ({len(batch)} items). "
f"Set OPENFIGI_API_KEY secret or reduce OPENFIGI_BATCH below 10.")
continue
if resp.status_code != 200:
print(f" ⚠️ OpenFIGI returned HTTP {resp.status_code}, skipping batch")
continue
results = resp.json()
for cusip, result in zip(batch, results):
if "data" in result and result["data"]:
for figi_item in result["data"]:
ticker = figi_item.get("ticker", "")
exch = figi_item.get("exchCode", "")
if exch in ("US", "UN", "UW", "UA"):
mapping[cusip] = ticker
break
else:
mapping[cusip] = result["data"][0].get("ticker", "")
except Exception as e:
print(f" ⚠️ OpenFIGI batch failed: {e}")
time.sleep(0.5)
return mapping
# ── Step 5: Split check ───────────────────────────────────────────────────────
def _is_valid_equity_ticker(ticker: str) -> bool:
"""
Rejects non-equity strings that OpenFIGI sometimes returns:
- Bond descriptions like 'BRKR 6.375 09/01/28'
- Multi-word strings
- Tickers longer than 6 chars (options, bonds)
"""
if not ticker or " " in ticker:
return False
if len(ticker) > 6:
return False
# Must start with a letter (real equity tickers never start with a digit)
if not ticker[0].isalpha():
return False
import re
return bool(re.match(r'^[A-Z0-9./\-]+$', ticker.upper()))
def check_recent_splits(tickers: list[str]) -> dict[str, float]:
try:
import yfinance as yf
from datetime import timedelta
except ImportError:
return {}
splits = {}
cutoff = date.today() - timedelta(days=120)
for ticker in tickers:
if not _is_valid_equity_ticker(ticker):
continue
yf_ticker = ticker.replace("/", "-") # BRK/B → BRK-B for yfinance
try:
hist = yf.Ticker(yf_ticker).splits
if hist.empty:
continue
recent = hist[hist.index.date >= cutoff]
if not recent.empty:
ratio = float(recent.iloc[-1])
splits[ticker] = ratio # store under original ticker key
print(f" ⚠️ Split: {ticker} ratio {ratio}")
except Exception:
pass
return splits
# ── Main ──────────────────────────────────────────────────────────────────────
def run():
today_str = date.today().isoformat()
output_path = DATA_DIR / f"{today_str}_raw_holdings.json"
all_data = {}
all_cusips = set()
print(f"\n{'='*60}")
print(f"SEC EDGAR Fetch – {today_str}")
print(f"{'='*60}")
for name, cik in FILERS.items():
print(f"\n▶ {name} (CIK: {cik})")
filing_meta = get_latest_13f_filing(cik)
if not filing_meta:
all_data[name] = {"error": "no_filing", "cik": cik}
continue
print(f" Filing: {filing_meta['form']} on {filing_meta['filingDate']}"
+ (" ⚠️ AMENDMENT" if filing_meta["isAmendment"] else ""))
xml_text = download_infotable(filing_meta)
if not xml_text:
all_data[name] = {"error": "no_xml", "cik": cik, "meta": filing_meta}
continue
holdings = parse_infotable(xml_text)
if not holdings:
all_data[name] = {"error": "no_holdings_parsed", "cik": cik, "meta": filing_meta}
continue
print(f" ✅ {len(holdings)} positions parsed")
# AQR and similar quant funds file 10k+ positions (index replication).
# Cluster signal from a quant fund holding 20k stocks is meaningless.
# Cap at top 500 by value so they don't flood the CUSIP pool.
MAX_POSITIONS_PER_FILER = 500
original_count = len(holdings)
if original_count > MAX_POSITIONS_PER_FILER:
holdings = sorted(holdings, key=lambda h: h["value_usd_thousands"], reverse=True)
holdings = holdings[:MAX_POSITIONS_PER_FILER]
print(f" ✂️ Capped to top {MAX_POSITIONS_PER_FILER} positions by value "
f"(was {original_count} total)")
for h in holdings:
if h["cusip"]:
all_cusips.add(h["cusip"])
all_data[name] = {
"cik": cik,
"meta": filing_meta,
"holdings": holdings,
"total_value":sum(h["value_usd_thousands"] for h in holdings),
"fetched_at": datetime.utcnow().isoformat(),
}
print(f"\n🔍 Mapping {len(all_cusips)} CUSIPs to tickers via OpenFIGI...")
cusip_to_ticker = map_cusips_to_tickers(list(all_cusips))
print(f" Mapped: {len(cusip_to_ticker)} / {len(all_cusips)}")
all_tickers = set()
for filer_data in all_data.values():
if "holdings" not in filer_data:
continue
for h in filer_data["holdings"]:
h["ticker"] = cusip_to_ticker.get(h["cusip"], "")
if h["ticker"]:
all_tickers.add(h["ticker"])
print(f"\n🔀 Checking splits on {len(all_tickers)} tickers...")
splits = check_recent_splits(list(all_tickers))
output = {
"date": today_str,
"cusip_to_ticker": cusip_to_ticker,
"recent_splits": splits,
"filers": all_data,
}
# Atomic write: write to temp file first, then rename (prevents corrupt files on crash)
tmp_path = output_path.with_suffix(".tmp")
with open(tmp_path, "w") as f:
json.dump(output, f, indent=2, default=str)
tmp_path.replace(output_path)
filers_ok = sum(1 for v in all_data.values() if "holdings" in v)
print(f"\n✅ Saved to {output_path}")
print(f" Filers with data: {filers_ok} / {len(FILERS)}")
missing = len(FILERS) - filers_ok
if missing > len(FILERS) * 0.3:
raise RuntimeError(f"Too many filers missing: {missing}/{len(FILERS)}")
if __name__ == "__main__":
run()
================================================
FILE: src/multi_quarter.py
================================================
"""
multi_quarter.py
Analyzes multi-quarter position building patterns.
A "Silent Build" over 3–4 quarters is a much stronger signal than
a single large buy in one quarter, which can be momentum-chasing or
window-dressing.
"""
import json
from datetime import date
from pathlib import Path
from config import DATA_DIR, MULTI_QUARTER_BUILD_MIN, MULTI_QUARTER_BONUS, MULTI_QUARTER_MAX
def load_historical_parsed(today_str: str) -> list[dict]:
"""
Loads up to MULTI_QUARTER_MAX previous *_holdings_parsed.json files,
most recent first, excluding today.
"""
today = date.fromisoformat(today_str)
candidates = sorted(DATA_DIR.glob("*_holdings_parsed.json"), reverse=True)
results = []
for c in candidates:
try:
d = date.fromisoformat(c.name[:10])
if d < today:
with open(c) as f:
results.append(json.load(f))
if len(results) >= MULTI_QUARTER_MAX:
break
except (ValueError, json.JSONDecodeError):
continue
return results # most recent first
def build_multi_quarter_signals(today_str: str) -> dict[str, dict]:
"""
For every ticker seen across historical quarters, computes:
- How many quarters had net buying activity
- Average delta pct per building quarter
- Slope of portfolio weight (positive = growing conviction)
- Silent build flag (small but consistent adds)
Returns {ticker: signal_dict} only for tickers with 2+ build quarters.
"""
history = load_historical_parsed(today_str)
if len(history) < 2:
print(f" ⚠️ Multi-quarter: only {len(history)} historical quarter(s) available. Signals will be sparse.")
if not history:
return {}
# Aggregate per ticker, per quarter
ticker_quarters: dict[str, list[dict]] = {}
for quarter_data in history:
quarter_str = quarter_data.get("date", "")
for filer_name, filer_data in quarter_data.get("filers", {}).items():
for pos in filer_data.get("positions", []):
ticker = pos.get("ticker") or pos.get("cusip", "")
if not ticker:
continue
if ticker not in ticker_quarters:
ticker_quarters[ticker] = []
ticker_quarters[ticker].append({
"quarter": quarter_str,
"filer": filer_name,
"delta_type": pos["delta"]["type"],
"delta_pct": pos["delta"].get("delta_pct"),
"port_weight": pos["port_weight_pct"],
})
signals = {}
for ticker, entries in ticker_quarters.items():
quarters_seen = sorted(set(e["quarter"] for e in entries), reverse=True)
build_quarters = 0
delta_pcts: list[float] = []
weights_by_quarter: list[float] = []
for q in quarters_seen:
q_entries = [e for e in entries if e["quarter"] == q]
has_buy = any(e["delta_type"] in ("NEW", "ADDED") for e in q_entries)
has_reduce = any(e["delta_type"] in ("REDUCED", "SOLD") for e in q_entries)
if has_buy and not has_reduce:
build_quarters += 1
for e in q_entries:
if e["delta_pct"] is not None:
delta_pcts.append(abs(e["delta_pct"]))
avg_w = sum(e["port_weight"] for e in q_entries) / len(q_entries)
weights_by_quarter.append(avg_w)
if build_quarters < 2:
continue
avg_delta = sum(delta_pcts) / len(delta_pcts) if delta_pcts else 0.0
# Weight slope: positive means portfolio weight growing over time
# weights_by_quarter[0] = most recent, [-1] = oldest
slope = 0.0
if len(weights_by_quarter) >= 2:
slope = (weights_by_quarter[0] - weights_by_quarter[-1]) / len(weights_by_quarter)
# Silent Build: 3+ quarters of small, consistent adds (5–25% delta)
silent_build = (
build_quarters >= 3
and len(delta_pcts) >= 3
and all(5.0 <= d <= 25.0 for d in delta_pcts[-3:])
)
# Build score: more quarters + higher avg delta + positive slope
build_score = (build_quarters / 4.0) * max(avg_delta, 1.0) * (1.0 + max(slope, 0.0))
flags = []
if build_quarters >= MULTI_QUARTER_BUILD_MIN:
flags.append("MULTI_QUARTER_BUILD")
if build_quarters >= 5:
flags.append("STRONG_BUILD")
if silent_build:
flags.append("SILENT_ACCUMULATION")
signals[ticker] = {
"build_quarters": build_quarters,
"total_quarters": len(quarters_seen),
"avg_delta_pct": round(avg_delta, 1),
"weight_slope": round(slope, 3),
"build_score": round(build_score, 2),
"silent_build": silent_build,
"flags": flags,
}
return signals
def get_multiplier(ticker: str, signals: dict[str, dict]) -> float:
"""Returns a score multiplier based on multi-quarter conviction signal."""
if ticker not in signals:
return 1.0
bq = signals[ticker]["build_quarters"]
if bq >= 5:
return MULTI_QUARTER_BONUS * 1.3
if bq >= 3:
return MULTI_QUARTER_BONUS
if bq >= 2:
return 1.2
return 1.0
================================================
FILE: src/notify.py
================================================
"""
notify.py
Sends pipeline failure alerts via Gmail.
Called from GitHub Actions on workflow failure so silent crashes
don't go unnoticed. Uses the same GMAIL_ADDRESS / GMAIL_APP_PASSWORD
secrets already configured for the report.
"""
import os
import smtplib
import sys
import traceback
from datetime import date
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from config import GMAIL_SMTP_HOST, GMAIL_SMTP_PORT
def send_alert(subject: str, body: str):
"""
Sends a plain-text alert email to GMAIL_ADDRESS.
Silently skips if credentials are not set (local dev).
"""
gmail_address = os.environ.get("GMAIL_ADDRESS", "")
gmail_password = os.environ.get("GMAIL_APP_PASSWORD", "")
if not gmail_address or not gmail_password:
print(f"[notify] No Gmail credentials set – alert not sent.\n{subject}")
return
msg = MIMEMultipart("alternative")
msg["Subject"] = subject
msg["From"] = gmail_address
msg["To"] = gmail_address
html_body = f"""
📈 Historical Performance (90-day stock returns)
{_fmt(ar90)}
Avg 90d Return
{wr90 if wr90 is not None else '—'}{'%' if wr90 else ''}
90d Win Rate
{_fmt(ar180)}
Avg 180d Return
{s.get('total_signals','—')}
Total Signals
{'
' if rows_html else ''}
⚠️ Past stock returns do not predict option profits. Options can expire worthless even when the stock moves in the right direction.
"""
def generate_html_report(analysis: dict, backtest: dict | None = None) -> str:
today_str = analysis["date"]
top5 = analysis.get("round1_top5", [])
options_recs = analysis.get("options_recs", [])
market_context = analysis.get("market_context", "")
portfolio_note = analysis.get("portfolio_note", "")
disclaimer = analysis.get("disclaimer", "")
backtest_html = generate_backtest_html(backtest) if backtest else ""
# Build options recommendations section
options_html = ""
options_by_ticker = {r["stock_ticker"]: r for r in options_recs}
for stock in top5:
ticker = stock["ticker"]
opt = options_by_ticker.get(ticker, {})
primary_flag = stock.get("primary_flag", "")
flags_html = flag_badge(primary_flag) if primary_flag else ""
# Buyers list – prefer enriched filer_details (port weight + delta) if available
filer_details = stock.get("filer_details", [])
if filer_details:
buyer_items = []
for fd in filer_details:
name = fd.get("filer", "")
port_pct = fd.get("port_weight_pct")
delta_type = fd.get("delta_type", "")
delta_pct = fd.get("delta_pct")
detail_parts = []
if port_pct is not None:
detail_parts.append(f"{port_pct:.2f}% of port")
if delta_type == "NEW":
detail_parts.append("NEW")
elif delta_pct is not None:
detail_parts.append(f"{delta_pct:+.0f}%")
detail = f" ({', '.join(detail_parts)})" if detail_parts else ""
buyer_items.append(f"
{ticker}
{stock.get('company_name','')}
{stock.get('conviction_score', '')}/100
CONVICTION SCORE
{flags_html}
{_post_filing_block(stock.get("post_filing_perf", {}))}
Investment Thesis
{stock.get('thesis','')}
RISK NOTE
{stock.get('risk_factors','')}
{"" if not opt else f'''
📈 RECOMMENDED OPTION TRADE
SYMBOL
{opt.get("option_symbol","")}
TYPE / STRIKE
{opt.get("option_type","")} @ ${opt.get("strike","")}
EXPIRY
{opt.get("expiration","")}
MID PRICE
${opt.get("entry_price_mid","?")}
MAX RISK / CONTRACT
${opt.get("max_risk_per_contract","?")}
PROFIT TARGET
{opt.get("profit_target","")}
Rationale: {opt.get("option_rationale","")}
Stop Loss: {opt.get("stop_loss","")} |
Greeks: {opt.get("greeks_note","Unknown")}
'''}
"""
html = f"""
QUARTERLY INSTITUTIONAL INTELLIGENCE
SEC 13F Smart Money Report
{today_str} · 13 Monitored Institutions · Top 5 Picks
Market Context
{market_context}
{backtest_html}
🎯 Top 5 Conviction Picks + Option Trades
{options_html}
{f'
Portfolio Sizing Note
{portfolio_note}
' if portfolio_note else ''}
⚠️ DISCLAIMER: {disclaimer}
Data limitations: 13F filings reflect long equity positions over $200K with up to 45-day delay.
Portfolio weights use long-only reported AUM (cash, shorts, bonds excluded – weights are systematically overstated).
Stock splits have been adjusted. Option prices are from Tradier at time of analysis and change constantly.
This report is generated automatically and does not constitute investment advice.
Generated automatically by SEC 13F Smart Money Analyzer ·
Data: SEC EDGAR + Tradier · Analysis: Claude AI
"""
return html
def send_gmail(html_content: str, today_str: str):
"""
Sends the report via Gmail using App Password (no OAuth required).
Both GMAIL_ADDRESS and GMAIL_APP_PASSWORD come from GitHub Secrets.
"""
gmail_address = os.environ.get("GMAIL_ADDRESS", "")
gmail_password = os.environ.get("GMAIL_APP_PASSWORD", "")
if not gmail_address or not gmail_password:
raise ValueError("GMAIL_ADDRESS and GMAIL_APP_PASSWORD must be set as GitHub Secrets")
subject = REPORT_SUBJECT.format(date=today_str)
msg = MIMEMultipart("alternative")
msg["Subject"] = subject
msg["From"] = gmail_address
msg["To"] = gmail_address # send to yourself
msg.attach(MIMEText(html_content, "html"))
with smtplib.SMTP(GMAIL_SMTP_HOST, GMAIL_SMTP_PORT) as server:
server.ehlo()
server.starttls()
server.login(gmail_address, gmail_password)
server.sendmail(gmail_address, gmail_address, msg.as_string())
print(f" ✅ Email sent to {gmail_address}")
def run():
today_str = date.today().isoformat()
print(f"\n{'='*60}")
print(f"Report Generation & Gmail – {today_str}")
print(f"{'='*60}")
analysis = load_final_analysis(today_str)
# R-14 Fix: Validate before sending
recs = analysis.get("options_recs", [])
top5 = analysis.get("round1_top5", [])
if not top5 or not recs:
raise RuntimeError(
f"Report validation failed: top5={len(top5)}, options_recs={len(recs)}. "
"Aborting email send."
)
print(f"✅ Validation passed: {len(top5)} stocks, {len(recs)} option recommendations")
# Generate HTML
backtest = load_backtest(today_str)
if backtest:
print(f"📊 Backtest data loaded ({backtest['summary'].get('total_signals',0)} signals tracked)")
html = generate_html_report(analysis, backtest)
# Save report to /reports/
report_path = REPORTS_DIR / f"{today_str}_report.html"
with open(report_path, "w") as f:
f.write(html)
print(f"💾 HTML report saved to {report_path}")
# Send email
print(f"📧 Sending via Gmail...")
send_gmail(html, today_str)
print(f"\n🎉 Pipeline complete for {today_str}")
if __name__ == "__main__":
run()