quantwise 1.2.0 → 1.2.2

package/.claude/skills/uptrend-analyzer/scripts/calculators/sector_participation_calculator.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""
+Component 2: Sector Participation - Weight: 25%
+
+Evaluates how many sectors are participating in the uptrend and the
+uniformity of participation (spread between strongest and weakest).
+
+Data Source: Sector Summary CSV
+
+Sub-scores:
+  - Uptrend Count (60%): How many of 11 sectors are in uptrend
+  - Spread (40%): Max-min ratio spread (uniform = healthy, selective = weak)
+"""
+
+import sys
+from typing import Dict, List, Optional
+
+from data_fetcher import build_summary_from_timeseries
+
+
+# Monty's official dashboard thresholds
+OVERBOUGHT_THRESHOLD = 0.37   # Upper threshold
+OVERSOLD_THRESHOLD = 0.097    # Lower threshold
+
+
+def calculate_sector_participation(sector_summary: List[Dict],
+                                   sector_timeseries: Dict[str, List[Dict]]) -> Dict:
+    """
+    Calculate sector participation score.
+
+    Args:
+        sector_summary: List of sector summary rows
+        sector_timeseries: Dict mapping sector -> timeseries rows; used as
+                          fallback if sector_summary is unavailable
+
+    Returns:
+        Dict with score (0-100), signal, and detail fields
+    """
+    if not sector_summary:
+        if sector_timeseries:
+            sector_summary = build_summary_from_timeseries(sector_timeseries)
+            print("  (fallback: built sector summary from timeseries data)",
+                  file=sys.stderr)
+        else:
+            return {
+                "score": 50,
+                "signal": "NO DATA: Sector summary unavailable (neutral default)",
+                "data_available": False,
+                "uptrend_count": None,
+                "total_sectors": None,
+                "spread": None,
+                "sector_details": [],
+            }
+
+    total_sectors = len(sector_summary)
+    if total_sectors == 0:
+        return {
+            "score": 50,
+            "signal": "NO DATA: No sectors in summary",
+            "data_available": False,
+            "uptrend_count": 0,
+            "total_sectors": 0,
+            "spread": None,
+            "sector_details": [],
+        }
+
+    # Count sectors in uptrend
+    uptrend_count = sum(
+        1 for s in sector_summary
+        if s.get("Trend", "").lower() == "up"
+    )
+
+    # Get ratios for spread calculation
+    ratios = [s["Ratio"] for s in sector_summary
+              if s.get("Ratio") is not None]
+
+    if ratios:
+        max_ratio = max(ratios)
+        min_ratio = min(ratios)
+        spread = max_ratio - min_ratio
+    else:
+        max_ratio = None
+        min_ratio = None
+        spread = None
+
+    # Sub-score 1: Uptrend Count (60%)
+    count_score = _score_uptrend_count(uptrend_count, total_sectors)
+
+    # Sub-score 2: Spread (40%)
+    spread_score = _score_spread(spread) if spread is not None else 50
+
+    # Composite
+    raw_score = count_score * 0.60 + spread_score * 0.40
+    score = round(min(100, max(0, raw_score)))
+
+    # Identify overbought/oversold sectors
+    overbought = [s for s in sector_summary
+                  if s.get("Ratio") is not None and s["Ratio"] >= OVERBOUGHT_THRESHOLD]
+    oversold = [s for s in sector_summary
+                if s.get("Ratio") is not None and s["Ratio"] < OVERSOLD_THRESHOLD]
+
+    signal = _build_signal(score, uptrend_count, total_sectors, spread)
+
+    # Build sector details sorted by ratio descending
+    sector_details = []
+    for s in sorted(sector_summary, key=lambda x: x.get("Ratio") or 0, reverse=True):
+        sector_details.append({
+            "sector": s.get("Sector", "Unknown"),
+            "ratio": s.get("Ratio"),
+            "ratio_pct": round(s["Ratio"] * 100, 1) if s.get("Ratio") is not None else None,
+            "ma_10": s.get("10MA"),
+            "trend": s.get("Trend", ""),
+            "slope": s.get("Slope"),
+            "status": s.get("Status", ""),
+        })
+
+    return {
+        "score": score,
+        "signal": signal,
+        "data_available": True,
+        "uptrend_count": uptrend_count,
+        "total_sectors": total_sectors,
+        "count_score": round(count_score),
+        "spread": round(spread, 4) if spread is not None else None,
+        "spread_pct": round(spread * 100, 1) if spread is not None else None,
+        "spread_score": round(spread_score),
+        "max_ratio": max_ratio,
+        "min_ratio": min_ratio,
+        "overbought_count": len(overbought),
+        "overbought_sectors": [s.get("Sector", "") for s in overbought],
+        "oversold_count": len(oversold),
+        "oversold_sectors": [s.get("Sector", "") for s in oversold],
+        "sector_details": sector_details,
+    }
+
+
+def _score_uptrend_count(uptrend_count: int, total_sectors: int) -> float:
+    """Score based on number of sectors in uptrend.
+
+    10-11 sectors -> 100
+    8-9  sectors -> 80
+    6-7  sectors -> 60
+    4-5  sectors -> 40
+    2-3  sectors -> 20
+    0-1  sectors -> 0
+    """
+    if total_sectors == 0:
+        return 50
+
+    if uptrend_count >= 10:
+        return 100
+    elif uptrend_count >= 8:
+        return 80
+    elif uptrend_count >= 6:
+        return 60
+    elif uptrend_count >= 4:
+        return 40
+    elif uptrend_count >= 2:
+        return 20
+    else:
+        return 0
+
+
+def _score_spread(spread: float) -> float:
+    """Score based on max-min ratio spread (0-1 scale).
+
+    < 0.15 -> 100 (uniform participation)
+    0.15-0.25 -> 80 (healthy spread)
+    0.25-0.35 -> 60 (moderate dispersion)
+    0.35-0.45 -> 30 (wide divergence)
+    > 0.45 -> 0 (extremely selective)
+    """
+    if spread < 0.15:
+        return 100
+    elif spread < 0.25:
+        return 100 - (spread - 0.15) / 0.10 * 20
+    elif spread < 0.35:
+        return 80 - (spread - 0.25) / 0.10 * 20
+    elif spread < 0.45:
+        return 60 - (spread - 0.35) / 0.10 * 30
+    else:
+        return max(0, 30 - (spread - 0.45) / 0.10 * 30)
+
+
+def _build_signal(score: int, uptrend_count: int,
+                  total_sectors: int, spread: Optional[float]) -> str:
+    """Build human-readable signal."""
+    spread_pct = f", spread {round(spread * 100, 1)}%" if spread is not None else ""
+
+    if score >= 80:
+        return (f"BROAD PARTICIPATION: {uptrend_count}/{total_sectors} "
+                f"sectors uptrending{spread_pct}")
+    elif score >= 60:
+        return (f"HEALTHY: {uptrend_count}/{total_sectors} "
+                f"sectors uptrending{spread_pct}")
+    elif score >= 40:
+        return (f"MODERATE: {uptrend_count}/{total_sectors} "
+                f"sectors uptrending{spread_pct}")
+    elif score >= 20:
+        return (f"NARROW: {uptrend_count}/{total_sectors} "
+                f"sectors uptrending{spread_pct}")
+    else:
+        return (f"VERY NARROW: {uptrend_count}/{total_sectors} "
+                f"sectors uptrending{spread_pct}")

package/.claude/skills/uptrend-analyzer/scripts/calculators/sector_rotation_calculator.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""
+Component 3: Sector Rotation - Weight: 15%
+
+Evaluates whether cyclical (risk-on) or defensive (risk-off) sectors are
+leading, plus commodity sector dynamics for late-cycle detection.
+
+Data Source: Sector Summary CSV
+
+Sector Groups:
+  Cyclical:  Technology, Consumer Cyclical, Communication Services, Financial, Industrials
+  Defensive: Utilities, Consumer Defensive, Healthcare, Real Estate
+  Commodity:  Energy, Basic Materials
+
+Primary score: cyclical_avg - defensive_avg difference
+  > +0.15  -> 90-100 (strong risk-on)
+  +0.05~+0.15 -> 70-89 (healthy cyclical lead)
+  -0.05~+0.05 -> 45-69 (balanced)
+  -0.15~-0.05 -> 20-44 (defensive tilt)
+  < -0.15  -> 0-19  (strong risk-off)
+
+Commodity adjustment: if commodity_avg > both groups -> late cycle flag, penalty
+"""
+
+import sys
+from typing import Dict, List, Optional
+
+from data_fetcher import build_summary_from_timeseries
+
+
+# Sector classification
+CYCLICAL_SECTORS = [
+    "Technology", "Consumer Cyclical", "Communication Services",
+    "Financial", "Industrials",
+]
+DEFENSIVE_SECTORS = [
+    "Utilities", "Consumer Defensive", "Healthcare", "Real Estate",
+]
+COMMODITY_SECTORS = [
+    "Energy", "Basic Materials",
+]
+
+
+def calculate_sector_rotation(sector_summary: List[Dict],
+                              sector_timeseries: Dict[str, List[Dict]]) -> Dict:
+    """
+    Calculate sector rotation score.
+
+    Args:
+        sector_summary: List of sector summary rows
+        sector_timeseries: Dict mapping sector -> timeseries rows (reserved)
+
+    Returns:
+        Dict with score (0-100), signal, and detail fields
+    """
+    if not sector_summary:
+        if sector_timeseries:
+            sector_summary = build_summary_from_timeseries(sector_timeseries)
+            print("  (fallback: built sector summary from timeseries data)",
+                  file=sys.stderr)
+        else:
+            return {
+                "score": 50,
+                "signal": "NO DATA: Sector summary unavailable (neutral default)",
+                "data_available": False,
+                "cyclical_avg": None,
+                "defensive_avg": None,
+                "commodity_avg": None,
+                "difference": None,
+            }
+
+    # Build lookup by sector name
+    sector_map = {s["Sector"]: s for s in sector_summary if s.get("Sector")}
+
+    # Calculate group averages
+    cyclical_ratios = _get_group_ratios(sector_map, CYCLICAL_SECTORS)
+    defensive_ratios = _get_group_ratios(sector_map, DEFENSIVE_SECTORS)
+    commodity_ratios = _get_group_ratios(sector_map, COMMODITY_SECTORS)
+
+    cyclical_avg = _avg(cyclical_ratios) if cyclical_ratios else None
+    defensive_avg = _avg(defensive_ratios) if defensive_ratios else None
+    commodity_avg = _avg(commodity_ratios) if commodity_ratios else None
+
+    if cyclical_avg is None or defensive_avg is None:
+        return {
+            "score": 50,
+            "signal": "INCOMPLETE DATA: Cannot calculate rotation (neutral default)",
+            "data_available": False,
+            "cyclical_avg": cyclical_avg,
+            "defensive_avg": defensive_avg,
+            "commodity_avg": commodity_avg,
+            "difference": None,
+        }
+
+    difference = cyclical_avg - defensive_avg
+
+    # Map difference to base score
+    base_score = _difference_to_score(difference)
+
+    # Commodity adjustment: late-cycle penalty
+    late_cycle_flag = False
+    commodity_penalty = 0
+    if commodity_avg is not None:
+        if commodity_avg > cyclical_avg and commodity_avg > defensive_avg:
+            late_cycle_flag = True
+            # Stronger penalty if commodity leads by a lot
+            excess = commodity_avg - max(cyclical_avg, defensive_avg)
+            if excess > 0.10:
+                commodity_penalty = -10
+            else:
+                commodity_penalty = -5
+
+    score = round(min(100, max(0, base_score + commodity_penalty)))
+
+    signal = _build_signal(score, difference, late_cycle_flag)
+
+    # Build group details
+    cyclical_details = _build_group_details(sector_map, CYCLICAL_SECTORS)
+    defensive_details = _build_group_details(sector_map, DEFENSIVE_SECTORS)
+    commodity_details = _build_group_details(sector_map, COMMODITY_SECTORS)
+
+    return {
+        "score": score,
+        "signal": signal,
+        "data_available": True,
+        "cyclical_avg": round(cyclical_avg, 4),
+        "cyclical_avg_pct": round(cyclical_avg * 100, 1),
+        "defensive_avg": round(defensive_avg, 4),
+        "defensive_avg_pct": round(defensive_avg * 100, 1),
+        "commodity_avg": round(commodity_avg, 4) if commodity_avg is not None else None,
+        "commodity_avg_pct": round(commodity_avg * 100, 1) if commodity_avg is not None else None,
+        "difference": round(difference, 4),
+        "difference_pct": round(difference * 100, 1),
+        "late_cycle_flag": late_cycle_flag,
+        "commodity_penalty": commodity_penalty,
+        "cyclical_details": cyclical_details,
+        "defensive_details": defensive_details,
+        "commodity_details": commodity_details,
+    }
+
+
+def _get_group_ratios(sector_map: Dict[str, Dict],
+                      sector_names: List[str]) -> List[float]:
+    """Extract ratios for a group of sectors."""
+    ratios = []
+    for name in sector_names:
+        sector = sector_map.get(name)
+        if sector and sector.get("Ratio") is not None:
+            ratios.append(sector["Ratio"])
+    return ratios
+
+
+def _avg(values: List[float]) -> float:
+    """Simple average."""
+    return sum(values) / len(values)
+
+
+def _difference_to_score(diff: float) -> float:
+    """Map cyclical-defensive difference to score.
+
+    > +0.15  -> 90-100 (strong risk-on)
+    +0.05~+0.15 -> 70-89 (healthy cyclical lead)
+    -0.05~+0.05 -> 45-69 (balanced)
+    -0.15~-0.05 -> 20-44 (defensive tilt)
+    < -0.15  -> 0-19  (strong risk-off)
+    """
+    if diff > 0.15:
+        return min(100, 90 + (diff - 0.15) / 0.10 * 10)
+    elif diff > 0.05:
+        return 70 + (diff - 0.05) / 0.10 * 19
+    elif diff > -0.05:
+        return 45 + (diff + 0.05) / 0.10 * 24
+    elif diff > -0.15:
+        return 20 + (diff + 0.15) / 0.10 * 24
+    else:
+        return max(0, 19 + (diff + 0.15) / 0.10 * 19)
+
+
+def _build_signal(score: int, difference: float, late_cycle: bool) -> str:
+    """Build human-readable signal."""
+    diff_pct = round(difference * 100, 1)
+    late_str = " [LATE CYCLE WARNING]" if late_cycle else ""
+
+    if score >= 90:
+        return f"STRONG RISK-ON: Cyclical leads by {diff_pct}pp{late_str}"
+    elif score >= 70:
+        return f"RISK-ON: Cyclical leads by {diff_pct}pp{late_str}"
+    elif score >= 45:
+        return f"BALANCED: Cyclical-Defensive gap {diff_pct}pp{late_str}"
+    elif score >= 20:
+        return f"DEFENSIVE TILT: Defensive leads by {abs(diff_pct)}pp{late_str}"
+    else:
+        return f"STRONG RISK-OFF: Defensive leads by {abs(diff_pct)}pp{late_str}"
+
+
+def _build_group_details(sector_map: Dict[str, Dict],
+                         sector_names: List[str]) -> List[Dict]:
+    """Build detail rows for a sector group."""
+    details = []
+    for name in sector_names:
+        sector = sector_map.get(name)
+        if sector:
+            details.append({
+                "sector": name,
+                "ratio": sector.get("Ratio"),
+                "ratio_pct": round(sector["Ratio"] * 100, 1) if sector.get("Ratio") is not None else None,
+                "trend": sector.get("Trend", ""),
+                "slope": sector.get("Slope"),
+            })
+        else:
+            details.append({
+                "sector": name,
+                "ratio": None,
+                "ratio_pct": None,
+                "trend": "N/A",
+                "slope": None,
+            })
+    return details

package/.claude/skills/uptrend-analyzer/scripts/data_fetcher.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""
+Uptrend Analyzer - CSV Data Fetcher
+
+Downloads and parses Monty's Uptrend Ratio Dashboard CSV data from GitHub.
+No API key required - uses publicly available CSV files.
+
+Data Sources:
+- Timeseries: uptrend_ratio_timeseries.csv (all + 11 sectors, 2023/08~present)
+- Sector Summary: sector_summary.csv (latest snapshot)
+"""
+
+import csv
+import io
+import sys
+import time
+from typing import Dict, List, Optional
+
+try:
+    import requests
+except ImportError:
+    print("ERROR: requests library not found. Install with: pip install requests",
+          file=sys.stderr)
+    sys.exit(1)
+
+
+TIMESERIES_URL = (
+    "https://raw.githubusercontent.com/tradermonty/uptrend-dashboard/"
+    "main/data/uptrend_ratio_timeseries.csv"
+)
+SECTOR_SUMMARY_URL = (
+    "https://raw.githubusercontent.com/tradermonty/uptrend-dashboard/"
+    "main/data/sector_summary.csv"
+)
+
+
+WORKSHEET_TO_DISPLAY = {
+    "sec_basicmaterials": "Basic Materials",
+    "sec_communicationservices": "Communication Services",
+    "sec_consumercyclical": "Consumer Cyclical",
+    "sec_consumerdefensive": "Consumer Defensive",
+    "sec_energy": "Energy",
+    "sec_financial": "Financial",
+    "sec_healthcare": "Healthcare",
+    "sec_industrials": "Industrials",
+    "sec_realestate": "Real Estate",
+    "sec_technology": "Technology",
+    "sec_utilities": "Utilities",
+}
+
+# Monty's official dashboard thresholds (same as in sector_participation_calculator)
+OVERBOUGHT_THRESHOLD = 0.37
+OVERSOLD_THRESHOLD = 0.097
+
+
+def build_summary_from_timeseries(sector_timeseries: Dict[str, Dict]) -> List[Dict]:
+    """Build sector_summary-compatible list from timeseries latest rows.
+
+    Used as fallback when sector_summary.csv is unavailable.
+
+    Args:
+        sector_timeseries: Dict mapping worksheet name -> latest timeseries row
+            e.g. {"sec_technology": {"ratio": 0.288, "ma_10": 0.266, ...}}
+
+    Returns:
+        List of dicts matching sector_summary format:
+            [{"Sector": "Technology", "Ratio": 0.288, "10MA": 0.266, ...}]
+    """
+    rows = []
+    for ws_name, row in sector_timeseries.items():
+        display_name = WORKSHEET_TO_DISPLAY.get(ws_name, ws_name)
+        ratio = row.get("ratio")
+        status = ("Overbought" if ratio is not None and ratio > OVERBOUGHT_THRESHOLD else
+                  "Oversold" if ratio is not None and ratio < OVERSOLD_THRESHOLD else
+                  "Normal")
+        rows.append({
+            "Sector": display_name,
+            "Ratio": ratio,
+            "10MA": row.get("ma_10"),
+            "Trend": (row.get("trend") or "").capitalize(),
+            "Slope": row.get("slope"),
+            "Status": status,
+        })
+    return rows
+
+
+class UptrendDataFetcher:
+    """Client for Monty's Uptrend Ratio Dashboard CSV data"""
+
+    def __init__(self):
+        self.session = requests.Session()
+        self._timeseries_cache: Optional[List[Dict]] = None
+        self._sector_summary_cache: Optional[List[Dict]] = None
+
+    def fetch_timeseries(self) -> List[Dict]:
+        """Download and parse the timeseries CSV.
+
+        Returns:
+            List of dicts with keys: worksheet, date, count, total, ratio,
+            ma_10, slope, trend. Numeric fields cast to float/int.
+        """
+        if self._timeseries_cache is not None:
+            return self._timeseries_cache
+
+        try:
+            response = self.session.get(TIMESERIES_URL, timeout=30)
+            response.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            print(f"WARNING: Failed to fetch timeseries CSV: {e}",
+                  file=sys.stderr)
+            return []
+
+        rows = []
+        reader = csv.DictReader(io.StringIO(response.text))
+        for row in reader:
+            parsed = _parse_timeseries_row(row)
+            if parsed:
+                rows.append(parsed)
+
+        self._timeseries_cache = rows
+        return rows
+
+    def fetch_sector_summary(self) -> List[Dict]:
+        """Download and parse the sector summary CSV.
+
+        Returns:
+            List of dicts with keys: Sector, Ratio, 10MA, Trend, Slope, Status.
+            Numeric fields cast to float.
+        """
+        if self._sector_summary_cache is not None:
+            return self._sector_summary_cache
+
+        try:
+            response = self.session.get(SECTOR_SUMMARY_URL, timeout=30)
+            response.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            print(f"WARNING: Failed to fetch sector summary CSV: {e}",
+                  file=sys.stderr)
+            return []
+
+        rows = []
+        reader = csv.DictReader(io.StringIO(response.text))
+        for row in reader:
+            parsed = _parse_sector_summary_row(row)
+            if parsed:
+                rows.append(parsed)
+
+        self._sector_summary_cache = rows
+        return rows
+
+    def get_all_timeseries(self) -> List[Dict]:
+        """Get timeseries filtered to worksheet=='all', sorted by date ascending."""
+        data = self.fetch_timeseries()
+        filtered = [r for r in data if r["worksheet"] == "all"]
+        filtered.sort(key=lambda r: r["date"])
+        return filtered
+
+    def get_sector_timeseries(self, sector: str) -> List[Dict]:
+        """Get timeseries for a specific sector worksheet, sorted by date ascending."""
+        data = self.fetch_timeseries()
+        filtered = [r for r in data if r["worksheet"] == sector]
+        filtered.sort(key=lambda r: r["date"])
+        return filtered
+
+    def get_latest_all(self) -> Optional[Dict]:
+        """Get the most recent 'all' row."""
+        ts = self.get_all_timeseries()
+        return ts[-1] if ts else None
+
+    def get_all_sector_latest(self) -> Dict[str, Dict]:
+        """Get latest row for each sector (excluding 'all').
+
+        Returns:
+            Dict mapping sector name -> latest timeseries row
+        """
+        data = self.fetch_timeseries()
+        sectors: Dict[str, Dict] = {}
+        for row in data:
+            ws = row["worksheet"]
+            if ws == "all":
+                continue
+            if ws not in sectors or row["date"] > sectors[ws]["date"]:
+                sectors[ws] = row
+        return sectors
+
+
+def _parse_timeseries_row(row: Dict) -> Optional[Dict]:
+    """Parse a timeseries CSV row, casting numeric fields."""
+    try:
+        return {
+            "worksheet": row.get("worksheet", "").strip(),
+            "date": row.get("date", "").strip(),
+            "count": _safe_int(row.get("count")),
+            "total": _safe_int(row.get("total")),
+            "ratio": _safe_float(row.get("ratio")),
+            "ma_10": _safe_float(row.get("ma_10")),
+            "slope": _safe_float(row.get("slope")),
+            "trend": row.get("trend", "").strip(),
+        }
+    except (ValueError, TypeError):
+        return None
+
+
+def _parse_sector_summary_row(row: Dict) -> Optional[Dict]:
+    """Parse a sector summary CSV row, casting numeric fields."""
+    try:
+        return {
+            "Sector": row.get("Sector", "").strip(),
+            "Ratio": _safe_float(row.get("Ratio")),
+            "10MA": _safe_float(row.get("10MA")),
+            "Trend": row.get("Trend", "").strip(),
+            "Slope": _safe_float(row.get("Slope")),
+            "Status": row.get("Status", "").strip(),
+        }
+    except (ValueError, TypeError):
+        return None
+
+
+def _safe_float(value) -> Optional[float]:
+    """Convert to float, return None if empty or invalid."""
+    if value is None or str(value).strip() == "":
+        return None
+    try:
+        return float(value)
+    except (ValueError, TypeError):
+        return None
+
+
+def _safe_int(value) -> Optional[int]:
+    """Convert to int, return None if empty or invalid."""
+    if value is None or str(value).strip() == "":
+        return None
+    try:
+        return int(float(value))
+    except (ValueError, TypeError):
+        return None