Split View: 코어-새틀라이트 ETF 자동 리밸런싱

# Target: 6-8% annual return, max drawdown within 15%
# For: 10-15 years before retirement, principal preservation priority
portfolio:
  name: 'Stable Growth'
  core_weight: 0.80
  satellite_weight: 0.20

  core:
    - ticker: 'KODEX US S&P500TR'
      weight: 0.30
      role: 'US market beta'
    - ticker: 'KODEX 200'
      weight: 0.15
      role: 'Korean market beta'
    - ticker: 'TIGER US Treasury 10Y Futures'
      weight: 0.20
      role: 'Defense during rate declines'
    - ticker: 'KODEX Composite Bond (AA- and above) Active'
      weight: 0.15
      role: 'Stable interest income'

  satellite:
    - ticker: 'TIGER Gold & Silver Futures (H)'
      weight: 0.10
      role: 'Inflation hedge'
    - ticker: 'TIGER US Dividend Dow Jones'
      weight: 0.10
      role: 'Dividend income'

  expected:
    annual_return: '6-8%'
    max_drawdown: '-15%'
    total_expense_ratio: '0.07%'

# Target: 10-12% annual return, willing to accept 25% max drawdown
# For: 15+ year investment horizon, aggressive growth
portfolio:
  name: 'Growth-Oriented'
  core_weight: 0.65
  satellite_weight: 0.35

  core:
    - ticker: 'TIGER US S&P500'
      weight: 0.35
      role: 'US market beta'
    - ticker: 'TIGER US NASDAQ100'
      weight: 0.15
      role: 'Tech stock growth'
    - ticker: 'KODEX 200'
      weight: 0.10
      role: 'Korean market beta'
    - ticker: 'TIGER US Treasury 10Y Futures'
      weight: 0.05
      role: 'Minimum bond allocation'

  satellite:
    - ticker: 'TIGER Semiconductor'
      weight: 0.12
      role: 'Semiconductor cycle alpha'
    - ticker: 'KODEX Secondary Battery Industry'
      weight: 0.08
      role: 'Secondary battery growth'
    - ticker: 'TIGER Fn Semiconductor TOP10'
      weight: 0.08
      role: 'Korean semiconductor concentration'
    - ticker: 'TIGER India Nifty50'
      weight: 0.07
      role: 'India market growth'

  expected:
    annual_return: '10-12%'
    max_drawdown: '-25%'
    total_expense_ratio: '0.15%'

# Target: Pursue positive returns in any market environment
# For: Investors who extremely dislike volatility
# Reference: Variation of Ray Dalio's All Weather strategy
portfolio:
  name: 'All-Weather'
  core_weight: 0.85
  satellite_weight: 0.15

  core:
    - ticker: 'TIGER US S&P500'
      weight: 0.25
      role: 'Returns during economic growth'
    - ticker: 'TIGER US Treasury 10Y Futures'
      weight: 0.25
      role: 'Recession defense'
    - ticker: 'KODEX US Treasury Ultra 30Y Futures (H)'
      weight: 0.15
      role: 'Deflation defense'
    - ticker: 'KODEX Composite Bond (AA- and above) Active'
      weight: 0.10
      role: 'Stable interest'
    - ticker: 'TIGER Gold & Silver Futures (H)'
      weight: 0.10
      role: 'Inflation hedge'

  satellite:
    - ticker: 'KODEX 200'
      weight: 0.10
      role: 'Korean market exposure'
    - ticker: 'TIGER Crude Oil Futures Enhanced (H)'
      weight: 0.05
      role: 'Commodity inflation response'

  expected:
    annual_return: '5-7%'
    max_drawdown: '-10%'
    total_expense_ratio: '0.09%'

"""
Core-Satellite Separate Rebalancing Engine
- Core: Twice a year + emergency when drift exceeds 5%
- Satellite: Quarterly + emergency when drift exceeds 7%
"""
from dataclasses import dataclass


@dataclass
class RebalanceRule:
    """Rebalancing rules by asset type."""
    section: str            # "core" or "satellite"
    scheduled_frequency: str  # "semi-annual" or "quarterly"
    drift_threshold: float    # Drift threshold
    min_trade_krw: int        # Minimum trade amount


RULES = {
    "core": RebalanceRule(
        section="core",
        scheduled_frequency="semi-annual",
        drift_threshold=0.05,
        min_trade_krw=200_000,
    ),
    "satellite": RebalanceRule(
        section="satellite",
        scheduled_frequency="quarterly",
        drift_threshold=0.07,
        min_trade_krw=100_000,
    ),
}


def check_section(
    section: str,
    holdings: dict,
    targets: list[dict],
    total_value: int,
) -> dict:
    """Determine if a specific section needs rebalancing."""
    rule = RULES[section]
    drift_alerts = []

    for target in targets:
        code = target["code"]
        current_value = holdings.get(code, {}).get("value_krw", 0)
        current_weight = current_value / total_value if total_value > 0 else 0
        target_weight = target["weight"]
        drift = abs(current_weight - target_weight)

        if drift > rule.drift_threshold:
            drift_alerts.append({
                "ticker": target["ticker"],
                "code": code,
                "target": target_weight,
                "current": round(current_weight, 4),
                "drift": round(drift, 4),
                "action_needed": True,
            })

    return {
        "section": section,
        "rule": rule,
        "needs_rebalancing": len(drift_alerts) > 0,
        "alerts": drift_alerts,
    }


def run_core_satellite_rebalance(portfolio_config: dict, holdings: dict):
    """Execute rebalancing for core and satellite separately."""
    total_value = sum(h["value_krw"] for h in holdings.values())

    print(f"Total assets: ₩{total_value:,}\n")

    for section in ["core", "satellite"]:
        targets = portfolio_config[section]
        result = check_section(section, holdings, targets, total_value)

        section_label = "Core" if section == "core" else "Satellite"
        print(f"=== {section_label} Check ===")
        print(f"Rebalancing frequency: {result['rule'].scheduled_frequency}")
        print(f"Drift threshold: ±{result['rule'].drift_threshold * 100}%")

        if result["needs_rebalancing"]:
            print(f"Status: Rebalancing needed")
            for alert in result["alerts"]:
                print(
                    f"  - {alert['ticker']}: "
                    f"Target {alert['target']*100:.1f}% / "
                    f"Current {alert['current']*100:.1f}% / "
                    f"Drift {alert['drift']*100:.1f}%p"
                )
        else:
            print("Status: Within normal range")
        print()


# Usage example
config = {
    "core": [
        {"ticker": "TIGER US S&P500", "code": "360750", "weight": 0.35},
        {"ticker": "KODEX 200", "code": "069500", "weight": 0.15},
        {"ticker": "TIGER US Treasury 10Y Futures", "code": "305080", "weight": 0.15},
    ],
    "satellite": [
        {"ticker": "TIGER Semiconductor", "code": "091230", "weight": 0.12},
        {"ticker": "KODEX Secondary Battery Industry", "code": "305720", "weight": 0.08},
        {"ticker": "TIGER India Nifty50", "code": "453810", "weight": 0.07},
    ],
}

holdings = {
    "360750": {"value_krw": 4_500_000},
    "069500": {"value_krw": 1_500_000},
    "305080": {"value_krw": 1_200_000},
    "091230": {"value_krw": 1_800_000},
    "305720": {"value_krw": 600_000},
    "453810": {"value_krw": 400_000},
}

run_core_satellite_rebalance(config, holdings)

"""Satellite ETF performance review and replacement decision."""

def evaluate_satellite(
    ticker: str,
    quarter_return: float,
    benchmark_return: float,
    thesis_valid: bool,
    cheaper_alternative: str | None = None,
) -> dict:
    """Determine whether a satellite ETF should be replaced."""
    excess_return = quarter_return - benchmark_return

    recommendation = "HOLD"
    reasons = []

    # If the investment thesis is invalidated
    if not thesis_valid:
        recommendation = "REPLACE"
        reasons.append("Investment thesis is no longer valid")

    # If underperforming benchmark for 3 consecutive quarters
    if excess_return < -0.05:
        recommendation = "REVIEW"
        reasons.append(
            f"Underperforming benchmark by {excess_return*100:.1f}%p"
        )

    # If a cheaper alternative exists
    if cheaper_alternative:
        reasons.append(f"Lower-fee alternative available: {cheaper_alternative}")

    return {
        "ticker": ticker,
        "quarter_return": f"{quarter_return*100:.1f}%",
        "excess_return": f"{excess_return*100:.1f}%p",
        "recommendation": recommendation,
        "reasons": reasons,
    }


# Quarterly review example
reviews = [
    evaluate_satellite(
        ticker="TIGER Semiconductor",
        quarter_return=0.12,
        benchmark_return=0.08,
        thesis_valid=True,
    ),
    evaluate_satellite(
        ticker="KODEX Secondary Battery Industry",
        quarter_return=-0.03,
        benchmark_return=0.08,
        thesis_valid=True,
    ),
    evaluate_satellite(
        ticker="TIGER India Nifty50",
        quarter_return=0.06,
        benchmark_return=0.08,
        thesis_valid=True,
        cheaper_alternative="KODEX India Nifty50 (Synthetic)",
    ),
]

print("=== Satellite Quarterly Review ===")
for r in reviews:
    print(f"\n{r['ticker']}")
    print(f"  Quarterly return: {r['quarter_return']}")
    print(f"  Excess return: {r['excess_return']}")
    print(f"  Verdict: {r['recommendation']}")
    if r["reasons"]:
        for reason in r["reasons"]:
            print(f"  - {reason}")

"""Calculate ETF correlations within a portfolio."""
import numpy as np


def check_correlation(returns_matrix: dict, threshold: float = 0.8) -> list:
    """Find ETF pairs with high correlation.

    Args:
        returns_matrix: {ticker: [daily return list]}
        threshold: Warning threshold for correlation coefficient

    Returns:
        List of ETF pairs with correlation exceeding the threshold
    """
    tickers = list(returns_matrix.keys())
    data = np.array([returns_matrix[t] for t in tickers])
    corr = np.corrcoef(data)

    high_corr_pairs = []
    for i in range(len(tickers)):
        for j in range(i + 1, len(tickers)):
            if abs(corr[i][j]) > threshold:
                high_corr_pairs.append({
                    "pair": (tickers[i], tickers[j]),
                    "correlation": round(corr[i][j], 3),
                    "warning": "Weakened diversification - consider reducing one position",
                })

    return high_corr_pairs


# Example: 60-day daily returns (simulation)
np.random.seed(42)
market = np.random.normal(0.0005, 0.01, 60)

sample_returns = {
    "S&P500": market + np.random.normal(0, 0.002, 60),
    "NASDAQ100": market * 1.3 + np.random.normal(0, 0.003, 60),
    "Semiconductor": market * 1.5 + np.random.normal(0, 0.005, 60),
    "US Treasury 10Y": -market * 0.3 + np.random.normal(0, 0.003, 60),
    "Gold": np.random.normal(0.0002, 0.008, 60),
}

alerts = check_correlation(sample_returns, threshold=0.7)

print("=== Correlation Alerts ===")
for alert in alerts:
    print(f"  {alert['pair'][0]} <-> {alert['pair'][1]}: "
          f"Correlation {alert['correlation']}")
    print(f"  -> {alert['warning']}")