quantwise 1.2.0 → 1.2.2

package/.claude/skills/canslim-screener/scripts/calculators/earnings_calculator.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+"""
+C Component - Current Quarterly Earnings Calculator
+
+Calculates CANSLIM 'C' component score based on quarterly EPS and revenue growth.
+
+O'Neil's Rule: "Look for companies whose current quarterly earnings per share
+are up at least 18-20% compared to the same quarter the prior year."
+
+Scoring:
+- 100 points: EPS +50%+ YoY AND Revenue +25%+ YoY (explosive growth)
+- 80 points: EPS +30-49% AND Revenue +15%+ (strong growth)
+- 60 points: EPS +18-29% AND Revenue +10%+ (meets CANSLIM minimum)
+- 40 points: EPS +10-17% (below threshold)
+- 0 points: EPS <10% or negative
+"""
+
+from typing import Dict, List, Optional
+
+
+def calculate_quarterly_growth(income_statements: List[Dict]) -> Dict:
+    """
+    Calculate quarterly EPS and revenue growth (year-over-year)
+
+    Args:
+        income_statements: List of quarterly income statements from FMP API
+                          (most recent quarter first, needs at least 5 quarters)
+
+    Returns:
+        Dict with:
+            - score: 0-100 points
+            - latest_qtr_eps_growth: YoY EPS growth percentage
+            - latest_qtr_revenue_growth: YoY revenue growth percentage
+            - latest_eps: Most recent quarterly EPS
+            - year_ago_eps: EPS from same quarter last year
+            - latest_revenue: Most recent quarterly revenue
+            - year_ago_revenue: Revenue from same quarter last year
+            - interpretation: Human-readable interpretation
+            - error: Error message if calculation failed
+
+    Example:
+        >>> income_stmts = client.get_income_statement("NVDA", period="quarter", limit=8)
+        >>> result = calculate_quarterly_growth(income_stmts)
+        >>> print(f"C Score: {result['score']}, EPS Growth: {result['latest_qtr_eps_growth']:.1f}%")
+    """
+    # Validate input
+    if not income_statements or len(income_statements) < 5:
+        return {
+            "score": 0,
+            "error": "Insufficient quarterly data (need at least 5 quarters for YoY comparison)",
+            "latest_qtr_eps_growth": None,
+            "latest_qtr_revenue_growth": None,
+            "latest_eps": None,
+            "year_ago_eps": None,
+            "latest_revenue": None,
+            "year_ago_revenue": None,
+            "interpretation": "Data unavailable"
+        }
+
+    # Extract most recent quarter (index 0) and year-ago quarter (index 4)
+    latest = income_statements[0]
+    year_ago = income_statements[4]
+
+    # Extract EPS (try multiple field names for compatibility)
+    latest_eps = latest.get("eps") or latest.get("epsdiluted") or latest.get("netIncomePerShare")
+    year_ago_eps = year_ago.get("eps") or year_ago.get("epsdiluted") or year_ago.get("netIncomePerShare")
+
+    # Extract revenue
+    latest_revenue = latest.get("revenue")
+    year_ago_revenue = year_ago.get("revenue")
+
+    # Validate extracted data
+    if latest_eps is None or year_ago_eps is None:
+        return {
+            "score": 0,
+            "error": "EPS data missing or invalid",
+            "latest_qtr_eps_growth": None,
+            "latest_qtr_revenue_growth": None,
+            "latest_eps": latest_eps,
+            "year_ago_eps": year_ago_eps,
+            "latest_revenue": latest_revenue,
+            "year_ago_revenue": year_ago_revenue,
+            "interpretation": "EPS data unavailable"
+        }
+
+    if latest_revenue is None or year_ago_revenue is None or year_ago_revenue == 0:
+        return {
+            "score": 0,
+            "error": "Revenue data missing or invalid",
+            "latest_qtr_eps_growth": None,
+            "latest_qtr_revenue_growth": None,
+            "latest_eps": latest_eps,
+            "year_ago_eps": year_ago_eps,
+            "latest_revenue": latest_revenue,
+            "year_ago_revenue": year_ago_revenue,
+            "interpretation": "Revenue data unavailable"
+        }
+
+    # Calculate year-over-year growth
+    # Use abs() for denominator to handle negative EPS (turnaround situations)
+    if year_ago_eps == 0:
+        # Handle zero/negative EPS edge case
+        if latest_eps > 0 and year_ago_eps <= 0:
+            # Turnaround situation (negative to positive)
+            eps_growth = 999.9  # Cap at very high growth
+        else:
+            eps_growth = 0
+    else:
+        eps_growth = ((latest_eps - year_ago_eps) / abs(year_ago_eps)) * 100
+
+    revenue_growth = ((latest_revenue - year_ago_revenue) / year_ago_revenue) * 100
+
+    # Calculate score
+    score = score_current_earnings(eps_growth, revenue_growth)
+
+    # Generate interpretation
+    interpretation = interpret_earnings_score(score, eps_growth, revenue_growth)
+
+    # Quality check: flag if revenue growth significantly lags EPS growth
+    quality_warning = None
+    if revenue_growth < (eps_growth * 0.5) and eps_growth > 20:
+        quality_warning = ("Revenue growth significantly lags EPS growth - "
+                          "investigate earnings quality (potential buyback-driven)")
+
+    return {
+        "score": score,
+        "latest_qtr_eps_growth": round(eps_growth, 1),
+        "latest_qtr_revenue_growth": round(revenue_growth, 1),
+        "latest_eps": latest_eps,
+        "year_ago_eps": year_ago_eps,
+        "latest_revenue": latest_revenue,
+        "year_ago_revenue": year_ago_revenue,
+        "latest_qtr_date": latest.get("date"),
+        "year_ago_qtr_date": year_ago.get("date"),
+        "interpretation": interpretation,
+        "quality_warning": quality_warning,
+        "error": None
+    }
+
+
+def score_current_earnings(eps_growth: float, revenue_growth: float) -> int:
+    """
+    Score C component based on quarterly EPS and revenue growth
+
+    Args:
+        eps_growth: Year-over-year EPS growth percentage
+        revenue_growth: Year-over-year revenue growth percentage
+
+    Returns:
+        Score (0-100)
+
+    Scoring Logic (from scoring_system.md):
+    - 100: EPS >=50% AND Revenue >=25%  (explosive)
+    - 80:  EPS 30-49% AND Revenue >=15% (strong)
+    - 60:  EPS 18-29% AND Revenue >=10% (meets CANSLIM minimum)
+    - 40:  EPS 10-17%                   (below threshold)
+    - 0:   EPS <10%                     (weak/negative)
+    """
+    # Exceptional growth
+    if eps_growth >= 50 and revenue_growth >= 25:
+        return 100
+
+    # Strong growth
+    if eps_growth >= 30 and revenue_growth >= 15:
+        return 80
+
+    # Meets CANSLIM minimum (18%+ EPS growth)
+    if eps_growth >= 18 and revenue_growth >= 10:
+        return 60
+
+    # Below threshold but positive
+    if eps_growth >= 10:
+        return 40
+
+    # Weak or negative growth
+    return 0
+
+
+def interpret_earnings_score(score: int, eps_growth: float, revenue_growth: float) -> str:
+    """
+    Generate human-readable interpretation of C component score
+
+    Args:
+        score: Component score (0-100)
+        eps_growth: YoY EPS growth percentage
+        revenue_growth: YoY revenue growth percentage
+
+    Returns:
+        Interpretation string
+    """
+    if score >= 90:
+        return (f"Exceptional - Explosive earnings acceleration "
+                f"(EPS +{eps_growth:.1f}%, Revenue +{revenue_growth:.1f}%)")
+
+    elif score >= 70:
+        return (f"Strong - Well above CANSLIM threshold "
+                f"(EPS +{eps_growth:.1f}%, Revenue +{revenue_growth:.1f}%)")
+
+    elif score >= 50:
+        return (f"Acceptable - Meets CANSLIM minimum 18% threshold "
+                f"(EPS +{eps_growth:.1f}%, Revenue +{revenue_growth:.1f}%)")
+
+    elif score >= 30:
+        return (f"Below threshold - Insufficient growth "
+                f"(EPS +{eps_growth:.1f}%, Revenue +{revenue_growth:.1f}%)")
+
+    else:
+        return (f"Weak - Does not meet CANSLIM criteria "
+                f"(EPS {eps_growth:+.1f}%, Revenue {revenue_growth:+.1f}%)")
+
+
+def detect_earnings_acceleration(income_statements: List[Dict]) -> Dict:
+    """
+    Detect if earnings are accelerating or decelerating (trend analysis)
+
+    Args:
+        income_statements: List of quarterly income statements (recent first)
+
+    Returns:
+        Dict with:
+            - trend: "accelerating", "stable", or "decelerating"
+            - recent_growth: Most recent quarter YoY growth
+            - prior_growth: Prior quarter YoY growth
+            - interpretation: Trend description
+
+    Note:
+        Earnings acceleration (recent > prior) is bullish signal per O'Neil.
+        Deceleration is early warning of potential weakness.
+    """
+    if len(income_statements) < 6:
+        return {
+            "trend": "unknown",
+            "recent_growth": None,
+            "prior_growth": None,
+            "interpretation": "Insufficient data for trend analysis"
+        }
+
+    # Most recent quarter vs year-ago
+    recent_eps = income_statements[0].get("eps", 0)
+    recent_year_ago_eps = income_statements[4].get("eps", 0.01)
+    recent_growth = ((recent_eps - recent_year_ago_eps) / abs(recent_year_ago_eps)) * 100 if recent_year_ago_eps else 0
+
+    # Prior quarter vs its year-ago
+    prior_eps = income_statements[1].get("eps", 0)
+    prior_year_ago_eps = income_statements[5].get("eps", 0.01)
+    prior_growth = ((prior_eps - prior_year_ago_eps) / abs(prior_year_ago_eps)) * 100 if prior_year_ago_eps else 0
+
+    # Determine trend
+    if recent_growth > prior_growth + 5:  # 5% threshold for significance
+        trend = "accelerating"
+        interpretation = f"Earnings accelerating ({recent_growth:.1f}% vs {prior_growth:.1f}% prior quarter)"
+    elif recent_growth < prior_growth - 5:
+        trend = "decelerating"
+        interpretation = f"Earnings decelerating ({recent_growth:.1f}% vs {prior_growth:.1f}% prior quarter) - Warning sign"
+    else:
+        trend = "stable"
+        interpretation = f"Earnings stable ({recent_growth:.1f}% vs {prior_growth:.1f}% prior quarter)"
+
+    return {
+        "trend": trend,
+        "recent_growth": round(recent_growth, 1),
+        "prior_growth": round(prior_growth, 1),
+        "interpretation": interpretation
+    }
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    print("Testing Earnings Calculator (C Component)...\n")
+
+    # Test case 1: Exceptional growth (should score 100)
+    test_data_exceptional = [
+        {"date": "2023-06-30", "eps": 2.70, "revenue": 13507000000},  # Q2 2023
+        {"date": "2023-03-31", "eps": 1.09, "revenue": 7192000000},
+        {"date": "2022-12-31", "eps": 0.88, "revenue": 6051000000},
+        {"date": "2022-09-30", "eps": 0.58, "revenue": 5931000000},
+        {"date": "2022-06-30", "eps": 0.51, "revenue": 6704000000},   # Q2 2022 (year-ago)
+    ]
+
+    result1 = calculate_quarterly_growth(test_data_exceptional)
+    print("Test 1: Exceptional Growth (NVDA-like)")
+    print(f"  Score: {result1['score']}/100")
+    print(f"  EPS Growth: {result1['latest_qtr_eps_growth']}%")
+    print(f"  Revenue Growth: {result1['latest_qtr_revenue_growth']}%")
+    print(f"  Interpretation: {result1['interpretation']}\n")
+
+    # Test case 2: Meets minimum (should score 60)
+    test_data_minimum = [
+        {"date": "2023-06-30", "eps": 1.20, "revenue": 10500000000},
+        {"date": "2023-03-31", "eps": 1.15, "revenue": 10200000000},
+        {"date": "2022-12-31", "eps": 1.10, "revenue": 10000000000},
+        {"date": "2022-09-30", "eps": 1.05, "revenue": 9800000000},
+        {"date": "2022-06-30", "eps": 1.00, "revenue": 9500000000},  # +20% EPS, +10.5% revenue
+    ]
+
+    result2 = calculate_quarterly_growth(test_data_minimum)
+    print("Test 2: Meets CANSLIM Minimum")
+    print(f"  Score: {result2['score']}/100")
+    print(f"  EPS Growth: {result2['latest_qtr_eps_growth']}%")
+    print(f"  Revenue Growth: {result2['latest_qtr_revenue_growth']}%")
+    print(f"  Interpretation: {result2['interpretation']}\n")
+
+    # Test case 3: Below threshold (should score 40)
+    test_data_weak = [
+        {"date": "2023-06-30", "eps": 1.12, "revenue": 10200000000},
+        {"date": "2023-03-31", "eps": 1.08, "revenue": 10100000000},
+        {"date": "2022-12-31", "eps": 1.05, "revenue": 10000000000},
+        {"date": "2022-09-30", "eps": 1.02, "revenue": 9900000000},
+        {"date": "2022-06-30", "eps": 1.00, "revenue": 9800000000},  # +12% EPS, +4% revenue
+    ]
+
+    result3 = calculate_quarterly_growth(test_data_weak)
+    print("Test 3: Below Threshold")
+    print(f"  Score: {result3['score']}/100")
+    print(f"  EPS Growth: {result3['latest_qtr_eps_growth']}%")
+    print(f"  Revenue Growth: {result3['latest_qtr_revenue_growth']}%")
+    print(f"  Interpretation: {result3['interpretation']}\n")
+
+    # Test case 4: Turnaround (negative to positive EPS)
+    test_data_turnaround = [
+        {"date": "2023-06-30", "eps": 0.50, "revenue": 10000000000},
+        {"date": "2023-03-31", "eps": 0.20, "revenue": 9500000000},
+        {"date": "2022-12-31", "eps": -0.10, "revenue": 9000000000},
+        {"date": "2022-09-30", "eps": -0.30, "revenue": 8500000000},
+        {"date": "2022-06-30", "eps": -0.40, "revenue": 8000000000},  # Turnaround situation
+    ]
+
+    result4 = calculate_quarterly_growth(test_data_turnaround)
+    print("Test 4: Turnaround (Negative to Positive)")
+    print(f"  Score: {result4['score']}/100")
+    print(f"  EPS Growth: {result4['latest_qtr_eps_growth']}%")
+    print(f"  Revenue Growth: {result4['latest_qtr_revenue_growth']}%")
+    print(f"  Interpretation: {result4['interpretation']}\n")
+
+    # Test acceleration detection
+    print("Test 5: Acceleration Detection")
+    accel = detect_earnings_acceleration(test_data_exceptional)
+    print(f"  Trend: {accel['trend']}")
+    print(f"  Recent growth: {accel['recent_growth']}%")
+    print(f"  Prior growth: {accel['prior_growth']}%")
+    print(f"  Interpretation: {accel['interpretation']}")
+
+    print("\n✓ All tests completed")

package/.claude/skills/canslim-screener/scripts/calculators/growth_calculator.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+"""
+A Component - Annual EPS Growth Calculator
+
+Calculates CANSLIM 'A' component score based on multi-year EPS CAGR and growth stability.
+
+O'Neil's Rule: "Annual earnings per share should be up 25% or more in each
+of the last three years."
+
+Scoring:
+- 90-100: CAGR 40%+, stable growth (no down years)
+- 70-89: CAGR 30-39%, stable
+- 50-69: CAGR 25-29% (meets CANSLIM minimum)
+- 30-49: CAGR 15-24% (below threshold)
+- 0-29: CAGR <15% or erratic growth
+
+Bonus: +10 points for stability (no down years)
+Penalty: -20% if revenue CAGR significantly lags EPS CAGR (buyback-driven growth)
+"""
+
+from typing import Dict, List, Optional
+
+
+def calculate_annual_growth(income_statements: List[Dict]) -> Dict:
+    """
+    Calculate 3-year EPS CAGR and growth stability
+
+    Args:
+        income_statements: List of annual income statements from FMP API
+                          (most recent year first, needs at least 4 years for 3-year CAGR)
+
+    Returns:
+        Dict with:
+            - score: 0-100 points
+            - eps_cagr_3yr: 3-year EPS compound annual growth rate (%)
+            - revenue_cagr_3yr: 3-year revenue CAGR (%) for validation
+            - stability: "stable" or "erratic"
+            - eps_values: List of EPS values (chronological)
+            - interpretation: Human-readable interpretation
+            - error: Error message if calculation failed
+    """
+    # Validate input
+    if not income_statements or len(income_statements) < 4:
+        return {
+            "score": 50,  # Default for insufficient data (neutral)
+            "error": "Insufficient annual data (need at least 4 years for 3-year CAGR)",
+            "eps_cagr_3yr": None,
+            "revenue_cagr_3yr": None,
+            "stability": "unknown",
+            "eps_values": None,
+            "interpretation": "Data unavailable"
+        }
+
+    # Extract EPS for last 4 years (most recent first in API response)
+    eps_values = []
+    revenue_values = []
+
+    for i in range(4):
+        stmt = income_statements[i]
+        eps = stmt.get("eps") or stmt.get("epsdiluted")
+        revenue = stmt.get("revenue")
+
+        if eps is None:
+            return {
+                "score": 0,
+                "error": f"Missing EPS data for year {stmt.get('date', 'unknown')}",
+                "eps_cagr_3yr": None,
+                "revenue_cagr_3yr": None,
+                "stability": "unknown",
+                "eps_values": None,
+                "interpretation": "EPS data incomplete"
+            }
+
+        if eps <= 0:
+            return {
+                "score": 0,
+                "error": f"Negative or zero EPS in year {stmt.get('date', 'unknown')} - cannot calculate CAGR",
+                "eps_cagr_3yr": None,
+                "revenue_cagr_3yr": None,
+                "stability": "unknown",
+                "eps_values": None,
+                "interpretation": "Negative EPS - not a CANSLIM candidate"
+            }
+
+        eps_values.append(eps)
+        revenue_values.append(revenue if revenue else 0)
+
+    # Reverse to chronological order (oldest first)
+    eps_values_chrono = eps_values[::-1]
+    revenue_values_chrono = revenue_values[::-1]
+
+    # Calculate 3-year CAGR
+    # CAGR = ((Ending Value / Beginning Value) ^ (1 / Number of Years)) - 1
+    eps_start = eps_values_chrono[0]  # 3 years ago
+    eps_end = eps_values_chrono[3]    # Current year
+    years = 3
+
+    eps_cagr = (((eps_end / eps_start) ** (1 / years)) - 1) * 100
+
+    # Calculate revenue CAGR for validation
+    revenue_start = revenue_values_chrono[0]
+    revenue_end = revenue_values_chrono[3]
+
+    if revenue_start > 0:
+        revenue_cagr = (((revenue_end / revenue_start) ** (1 / years)) - 1) * 100
+    else:
+        revenue_cagr = 0
+
+    # Check growth stability (no down years)
+    stable = all(eps_values_chrono[i] >= eps_values_chrono[i - 1]
+                 for i in range(1, len(eps_values_chrono)))
+
+    # Calculate score
+    score = score_annual_growth(eps_cagr, revenue_cagr, stable)
+
+    # Generate interpretation
+    interpretation = interpret_growth_score(score, eps_cagr, stable)
+
+    # Quality warning
+    quality_warning = None
+    if revenue_cagr < (eps_cagr * 0.5) and eps_cagr > 20:
+        quality_warning = ("Revenue CAGR significantly lags EPS CAGR - "
+                          "growth may be buyback-driven rather than organic")
+
+    return {
+        "score": score,
+        "eps_cagr_3yr": round(eps_cagr, 1),
+        "revenue_cagr_3yr": round(revenue_cagr, 1),
+        "stability": "stable" if stable else "erratic",
+        "eps_values": [round(eps, 2) for eps in eps_values_chrono],
+        "revenue_values": [int(rev) for rev in revenue_values_chrono],
+        "years_analyzed": len(eps_values_chrono),
+        "interpretation": interpretation,
+        "quality_warning": quality_warning,
+        "error": None
+    }
+
+
+def score_annual_growth(eps_cagr: float, revenue_cagr: float, stable: bool) -> int:
+    """
+    Score A component based on EPS CAGR, revenue validation, and stability
+
+    Args:
+        eps_cagr: 3-year EPS compound annual growth rate (%)
+        revenue_cagr: 3-year revenue CAGR (%)
+        stable: True if no down years, False if erratic
+
+    Returns:
+        Score (0-100)
+
+    Scoring Logic:
+    - Base score from EPS CAGR:
+      - 40%+: 90 points
+      - 30-39%: 70 points
+      - 25-29%: 50 points (meets CANSLIM minimum)
+      - 15-24%: 30 points
+      - <15%: 0 points
+    - Penalty: -20% if revenue CAGR < 50% of EPS CAGR (buyback concern)
+    - Bonus: +10 points if stable growth (no down years)
+    """
+    # Base score from EPS CAGR
+    if eps_cagr >= 40:
+        base_score = 90
+    elif eps_cagr >= 30:
+        base_score = 70
+    elif eps_cagr >= 25:
+        base_score = 50  # Meets CANSLIM minimum
+    elif eps_cagr >= 15:
+        base_score = 30
+    else:
+        base_score = 0
+
+    # Revenue growth validation penalty
+    if revenue_cagr < (eps_cagr * 0.5):
+        base_score = int(base_score * 0.8)  # 20% penalty
+
+    # Stability bonus
+    if stable:
+        base_score += 10
+
+    # Cap at 100
+    return min(base_score, 100)
+
+
+def interpret_growth_score(score: int, eps_cagr: float, stable: bool) -> str:
+    """
+    Generate human-readable interpretation of A component score
+
+    Args:
+        score: Component score (0-100)
+        eps_cagr: 3-year EPS CAGR (%)
+        stable: Growth stability flag
+
+    Returns:
+        Interpretation string
+    """
+    stability_text = "stable" if stable else "erratic"
+
+    if score >= 90:
+        return (f"Exceptional - {eps_cagr:.1f}% CAGR, {stability_text} growth trajectory")
+
+    elif score >= 70:
+        return (f"Strong - {eps_cagr:.1f}% CAGR, well above CANSLIM 25% threshold ({stability_text})")
+
+    elif score >= 50:
+        return (f"Acceptable - {eps_cagr:.1f}% CAGR meets CANSLIM minimum ({stability_text})")
+
+    elif score >= 30:
+        return (f"Below threshold - {eps_cagr:.1f}% CAGR insufficient (<25% required)")
+
+    else:
+        return (f"Weak - {eps_cagr:.1f}% CAGR does not meet CANSLIM criteria")
+
+
+def check_consistency(income_statements: List[Dict]) -> Dict:
+    """
+    Check year-over-year growth consistency (no down years is ideal)
+
+    Args:
+        income_statements: List of annual income statements (recent first)
+
+    Returns:
+        Dict with:
+            - down_years: Count of years with YoY decline
+            - consecutive_growth_years: Max consecutive years of growth
+            - growth_pattern: List of YoY growth rates
+    """
+    if len(income_statements) < 2:
+        return {
+            "down_years": None,
+            "consecutive_growth_years": None,
+            "growth_pattern": None,
+            "interpretation": "Insufficient data"
+        }
+
+    eps_values = []
+    for stmt in income_statements:
+        eps = stmt.get("eps") or stmt.get("epsdiluted")
+        if eps:
+            eps_values.append(eps)
+
+    # Reverse to chronological order
+    eps_values = eps_values[::-1]
+
+    # Calculate YoY growth rates
+    growth_pattern = []
+    for i in range(1, len(eps_values)):
+        if eps_values[i - 1] > 0:
+            yoy_growth = ((eps_values[i] - eps_values[i - 1]) / eps_values[i - 1]) * 100
+            growth_pattern.append(round(yoy_growth, 1))
+
+    # Count down years
+    down_years = sum(1 for g in growth_pattern if g < 0)
+
+    # Find max consecutive growth years
+    consecutive = 0
+    max_consecutive = 0
+    for g in growth_pattern:
+        if g >= 0:
+            consecutive += 1
+            max_consecutive = max(max_consecutive, consecutive)
+        else:
+            consecutive = 0
+
+    interpretation = f"{max_consecutive} consecutive years of growth, {down_years} down years"
+
+    return {
+        "down_years": down_years,
+        "consecutive_growth_years": max_consecutive,
+        "growth_pattern": growth_pattern,
+        "interpretation": interpretation
+    }
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    print("Testing Growth Calculator (A Component)...\n")
+
+    # Test case 1: Exceptional growth (NVDA-like, 40%+ CAGR, stable)
+    test_data_exceptional = [
+        {"date": "2023-01-31", "eps": 4.02, "revenue": 26974000000},  # FY2023
+        {"date": "2022-01-31", "eps": 4.44, "revenue": 26914000000},  # FY2022
+        {"date": "2021-01-31", "eps": 1.93, "revenue": 16675000000},  # FY2021
+        {"date": "2020-01-31", "eps": 1.67, "revenue": 10918000000},  # FY2020
+    ]
+
+    result1 = calculate_annual_growth(test_data_exceptional)
+    print("Test 1: Exceptional Growth (40%+ CAGR)")
+    print(f"  Score: {result1['score']}/100")
+    print(f"  EPS CAGR: {result1['eps_cagr_3yr']}%")
+    print(f"  Revenue CAGR: {result1['revenue_cagr_3yr']}%")
+    print(f"  Stability: {result1['stability']}")
+    print(f"  Interpretation: {result1['interpretation']}\n")
+
+    # Test case 2: Meets minimum (25-29% CAGR, stable)
+    test_data_minimum = [
+        {"date": "2023-12-31", "eps": 2.00, "revenue": 50000000000},
+        {"date": "2022-12-31", "eps": 1.60, "revenue": 45000000000},
+        {"date": "2021-12-31", "eps": 1.28, "revenue": 40000000000},
+        {"date": "2020-12-31", "eps": 1.02, "revenue": 36000000000},  # ~25% CAGR
+    ]
+
+    result2 = calculate_annual_growth(test_data_minimum)
+    print("Test 2: Meets CANSLIM Minimum (25% CAGR)")
+    print(f"  Score: {result2['score']}/100")
+    print(f"  EPS CAGR: {result2['eps_cagr_3yr']}%")
+    print(f"  Revenue CAGR: {result2['revenue_cagr_3yr']}%")
+    print(f"  Stability: {result2['stability']}")
+    print(f"  Interpretation: {result2['interpretation']}\n")
+
+    # Test case 3: Erratic growth (one down year)
+    test_data_erratic = [
+        {"date": "2023-12-31", "eps": 2.50, "revenue": 50000000000},
+        {"date": "2022-12-31", "eps": 1.80, "revenue": 45000000000},  # Down year
+        {"date": "2021-12-31", "eps": 2.00, "revenue": 48000000000},
+        {"date": "2020-12-31", "eps": 1.60, "revenue": 42000000000},
+    ]
+
+    result3 = calculate_annual_growth(test_data_erratic)
+    print("Test 3: Erratic Growth (One Down Year)")
+    print(f"  Score: {result3['score']}/100")
+    print(f"  EPS CAGR: {result3['eps_cagr_3yr']}%")
+    print(f"  Stability: {result3['stability']}")
+    print(f"  Interpretation: {result3['interpretation']}\n")
+
+    # Test consistency check
+    print("Test 4: Consistency Check")
+    consistency = check_consistency(test_data_exceptional)
+    print(f"  Down years: {consistency['down_years']}")
+    print(f"  Consecutive growth: {consistency['consecutive_growth_years']} years")
+    print(f"  Growth pattern: {consistency['growth_pattern']}")
+    print(f"  Interpretation: {consistency['interpretation']}")
+
+    print("\n✓ All tests completed")