40. Global Market Sector Rotation Monitoring System¶

services/sector-rotation-center/
├── src/
│   ├── main.py
│   ├── aggregator/
│   │   └── sector_data_aggregator.py
│   ├── scorer/
│   │   └── sector_strength_scorer.py
│   ├── detector/
│   │   ├── flow_detector.py
│   │   └── regime_shift_detector.py
│   ├── signal/
│   │   └── rotation_signal_generator.py
│   ├── api/
│   │   └── sector_api.py
│   ├── config.py
│   └── requirements.txt
├── Dockerfile
└── tests/

class SectorDataAggregator:
    def fetch_sector_data(self):
        return {
            # US Equity Sectors
            "US_Tech": fetch_sp500_tech(),
            "US_Finance": fetch_sp500_finance(),
            "US_Healthcare": fetch_sp500_healthcare(),
            "US_Consumer": fetch_sp500_consumer(),

            # Hong Kong Market Sectors
            "HK_Internet": fetch_hang_seng_tech(),
            "HK_Property": fetch_hang_seng_property(),
            "HK_Energy": fetch_hang_seng_energy(),

            # China A-Share Indices
            "A_CSI300": fetch_csi300(),
            "A_CYB50": fetch_china_cyb50(),
            "A_SSE50": fetch_sse50(),

            # Cryptocurrency Sectors
            "Crypto_Layer1": fetch_layer1_index(),
            "Crypto_DeFi": fetch_defi_index(),
            "Crypto_NFT": fetch_nft_index()
        }

import numpy as np

class SectorStrengthScorer:
    def score_sectors(self, sector_prices):
        scores = {}
        for sector, prices in sector_prices.items():
            returns = np.diff(np.log(prices))
            # Sharpe-like score: mean return / volatility
            score = np.mean(returns) / np.std(returns)
            scores[sector] = score
        return scores

    def rank_sectors(self, scores):
        return sorted(scores.items(), key=lambda x: x[1], reverse=True)

class FlowDetector:
    def detect_flow_shift(self, current_scores, previous_scores):
        flows = {}
        for sector in current_scores:
            flows[sector] = current_scores[sector] - previous_scores.get(sector, 0)
        return flows

    def identify_flow_leaders(self, flows, threshold=0.1):
        return {sector: flow for sector, flow in flows.items() 
                if abs(flow) > threshold}

class RegimeShiftDetector:
    def detect_regime_shift(self, sector_scores_history):
        shifts = {}
        for sector, score_series in sector_scores_history.items():
            if len(score_series) < 2:
                continue

            current_score = score_series[-1]
            previous_score = score_series[-2]

            if current_score > 0 and previous_score < 0:
                shifts[sector] = "Bear → Bull"
            elif current_score < 0 and previous_score > 0:
                shifts[sector] = "Bull → Bear"
        return shifts

class RotationSignalGenerator:
    def generate_rotation_signals(self, flow_shifts, regime_shifts, 
                                current_rankings):
        signals = []

        for sector, shift in regime_shifts.items():
            flow = flow_shifts.get(sector, 0)

            if flow > 0 and shift == "Bear → Bull":
                signals.append({
                    "sector": sector,
                    "action": "BUY",
                    "confidence": min(abs(flow), 1.0),
                    "reason": "Regime shift to bullish with positive flow"
                })
            elif flow < 0 and shift == "Bull → Bear":
                signals.append({
                    "sector": sector,
                    "action": "SELL",
                    "confidence": min(abs(flow), 1.0),
                    "reason": "Regime shift to bearish with negative flow"
                })

        return signals

from fastapi import APIRouter, HTTPException
from typing import Dict, List

router = APIRouter()

@router.get("/sectors/strengths")
async def get_sector_strengths():
    """Get current sector strength scores"""
    return {
        "timestamp": datetime.now().isoformat(),
        "scores": sector_strength_scorer.latest_scores,
        "rankings": sector_strength_scorer.latest_rankings
    }

@router.get("/sectors/flows")
async def get_sector_flows():
    """Get sector capital flow shifts"""
    return {
        "timestamp": datetime.now().isoformat(),
        "flows": flow_detector.latest_flows,
        "leaders": flow_detector.flow_leaders
    }

@router.get("/sectors/regime_shifts")
async def get_regime_shifts():
    """Get sector regime shift signals"""
    return {
        "timestamp": datetime.now().isoformat(),
        "shifts": regime_shift_detector.latest_shifts
    }

@router.get("/sectors/rotation_signals")
async def get_rotation_signals():
    """Get sector rotation trading signals"""
    return {
        "timestamp": datetime.now().isoformat(),
        "signals": rotation_signal_generator.latest_signals
    }

@router.get("/sectors/dashboard")
async def get_sector_dashboard():
    """Get comprehensive sector dashboard data"""
    return {
        "strengths": sector_strength_scorer.latest_scores,
        "flows": flow_detector.latest_flows,
        "shifts": regime_shift_detector.latest_shifts,
        "signals": rotation_signal_generator.latest_signals
    }

// SectorRotationView.tsx
interface SectorData {
  sector: string;
  strength: number;
  flow: number;
  regime: string;
  signal?: string;
}

const SectorRotationView: React.FC = () => {
  const [sectorData, setSectorData] = useState<SectorData[]>([]);

  return (
    <div className="sector-rotation-dashboard">
      {/* Sector Strength Heatmap */}
      <SectorStrengthHeatmap data={sectorData} />

      {/* Capital Flow Visualization */}
      <FlowVisualization data={sectorData} />

      {/* Regime Shift Timeline */}
      <RegimeShiftTimeline data={sectorData} />

      {/* Rotation Signals Table */}
      <RotationSignalsTable data={sectorData} />
    </div>
  );
};

# sector-rotation-config.yaml
sectors:
  us_equity:
    - US_Tech
    - US_Finance
    - US_Healthcare
    - US_Consumer

  hong_kong:
    - HK_Internet
    - HK_Property
    - HK_Energy

  china_a_share:
    - A_CSI300
    - A_CYB50
    - A_SSE50

  cryptocurrency:
    - Crypto_Layer1
    - Crypto_DeFi
    - Crypto_NFT

scoring:
  lookback_period: 20
  volatility_window: 60
  flow_threshold: 0.1

signals:
  confidence_threshold: 0.7
  max_signals_per_day: 5