연금저축과 DC형 퇴직연금 ETF 포트폴리오 설계 가이드 2026

from dataclasses import dataclass

@dataclass
class PensionAllocation:
    """연금 포트폴리오 자산배분 계산기"""
    age: int
    retirement_age: int = 60
    risk_tolerance: str = "moderate"  # conservative, moderate, aggressive
    account_type: str = "pension_savings"  # pension_savings, dc, irp

    # 위험 성향별 기본 주식 비중 (30세 기준)
    BASE_EQUITY = {"conservative": 50, "moderate": 70, "aggressive": 85}

    def equity_ratio(self) -> float:
        """연령에 따른 주식 비율 계산 (글라이드패스 반영)"""
        years_to_retire = max(self.retirement_age - self.age, 0)
        base = self.BASE_EQUITY[self.risk_tolerance]
        # 은퇴까지 남은 기간에 비례해 주식 비중 조정
        if years_to_retire >= 30:
            ratio = base
        elif years_to_retire <= 0:
            ratio = max(base * 0.35, 20)  # 은퇴 후 최소 20%
        else:
            decay = (30 - years_to_retire) / 30 * 0.65
            ratio = base * (1 - decay)
        return round(ratio, 1)

    def apply_dc_constraint(self, equity_pct: float) -> dict:
        """DC형/IRP 위험자산 70% 한도 적용"""
        if self.account_type in ("dc", "irp"):
            equity_pct = min(equity_pct, 70.0)
        safe_pct = 100.0 - equity_pct
        return {"equity": equity_pct, "safe": safe_pct}

    def build_allocation(self) -> dict:
        """전체 자산배분 구성"""
        eq = self.equity_ratio()
        constrained = self.apply_dc_constraint(eq)

        equity = constrained["equity"]
        safe = constrained["safe"]

        return {
            "국내주식": round(equity * 0.3, 1),
            "해외주식": round(equity * 0.55, 1),
            "신흥국주식": round(equity * 0.15, 1),
            "국내채권": round(safe * 0.5, 1),
            "해외채권": round(safe * 0.25, 1),
            "대체자산(금/리츠)": round(safe * 0.25, 1),
            "위험자산합계": equity,
            "안전자산합계": safe,
            "계좌유형": self.account_type,
        }


# 사용 예시
for age in [30, 40, 50, 60]:
    alloc = PensionAllocation(
        age=age, account_type="dc", risk_tolerance="moderate"
    )
    result = alloc.build_allocation()
    print(f"\n[{age}세 DC형 moderate]")
    for k, v in result.items():
        if isinstance(v, float):
            print(f"  {k}: {v}%")
        else:
            print(f"  {k}: {v}")

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np

def simulate_glide_path(
    start_age: int = 25,
    retire_age: int = 60,
    end_age: int = 85,
    initial_equity: float = 85.0,
    retire_equity: float = 40.0,
    final_equity: float = 25.0,
) -> dict:
    """
    글라이드패스 시뮬레이션
    - 축적기(start_age ~ retire_age): 주식 비중 점진 감소
    - 인출기(retire_age ~ end_age): 주식 비중 추가 감소
    """
    ages = list(range(start_age, end_age + 1))
    equity_ratios = []

    for age in ages:
        if age <= retire_age:
            # 축적기: 선형 감소
            progress = (age - start_age) / (retire_age - start_age)
            eq = initial_equity - (initial_equity - retire_equity) * progress
        else:
            # 인출기: 완만한 감소
            progress = (age - retire_age) / (end_age - retire_age)
            eq = retire_equity - (retire_equity - final_equity) * progress
        equity_ratios.append(round(eq, 1))

    bond_ratios = [round(100 - eq, 1) for eq in equity_ratios]

    # 시각화
    fig, ax = plt.subplots(figsize=(12, 6))
    ax.stackplot(
        ages,
        equity_ratios,
        bond_ratios,
        labels=["Equity (주식)", "Bond/Alt (채권/대체)"],
        colors=["#2563eb", "#94a3b8"],
        alpha=0.85,
    )
    ax.axvline(x=retire_age, color="red", linestyle="--", label="은퇴 시점")
    ax.set_xlabel("나이")
    ax.set_ylabel("비중 (%)")
    ax.set_title("연금 포트폴리오 글라이드패스")
    ax.legend(loc="upper right")
    ax.set_xlim(start_age, end_age)
    ax.set_ylim(0, 100)
    plt.tight_layout()
    plt.savefig("glide_path.png", dpi=150)
    plt.close()

    # 5년 단위 요약
    summary = {}
    for age, eq in zip(ages, equity_ratios):
        if age % 5 == 0 or age == retire_age:
            summary[age] = {"equity": eq, "bond": round(100 - eq, 1)}

    return summary


result = simulate_glide_path()
for age, alloc in result.items():
    phase = "인출기" if age >= 60 else "축적기"
    print(f"  {age}세 [{phase}]: 주식 {alloc['equity']}% / 채권 {alloc['bond']}%")

  25세 [축적기]: 주식 85.0% / 채권 15.0%
  30세 [축적기]: 주식 78.6% / 채권 21.4%
  35세 [축적기]: 주식 72.1% / 채권 27.9%
  40세 [축적기]: 주식 65.7% / 채권 34.3%
  45세 [축적기]: 주식 59.3% / 채권 40.7%
  50세 [축적기]: 주식 52.9% / 채권 47.1%
  55세 [축적기]: 주식 46.4% / 채권 53.6%
  60세 [인출기]: 주식 40.0% / 채권 60.0%
  65세 [인출기]: 주식 37.0% / 채권 63.0%
  70세 [인출기]: 주식 34.0% / 채권 66.0%
  75세 [인출기]: 주식 31.0% / 채권 69.0%
  80세 [인출기]: 주식 28.0% / 채권 72.0%
  85세 [인출기]: 주식 25.0% / 채권 75.0%

def optimize_tax_deduction(
    total_annual_saving: int,
    gross_salary: int,
    has_isa_maturity: bool = False,
    isa_transfer_amount: int = 0,
) -> dict:
    """
    연금저축/IRP 세액공제 최적화 계산기
    - total_annual_saving: 연간 연금 납입 가능 총액 (원)
    - gross_salary: 총급여 (원)
    - has_isa_maturity: ISA 만기 이전 여부
    - isa_transfer_amount: ISA에서 IRP로 이전하는 금액 (원)
    """
    # 세액공제율 결정
    if gross_salary <= 55_000_000:
        deduction_rate = 0.165
        bracket = "16.5%"
    else:
        deduction_rate = 0.132
        bracket = "13.2%"

    remaining = total_annual_saving

    # 1단계: 연금저축 600만 원
    pension_saving = min(remaining, 6_000_000)
    remaining -= pension_saving

    # 2단계: IRP 추가 납입 (합산 900만 원 한도)
    irp_limit = 9_000_000 - pension_saving
    irp_deposit = min(remaining, irp_limit)
    remaining -= irp_deposit

    # 3단계: ISA 만기 이전 추가 공제
    isa_extra_deduction = 0
    if has_isa_maturity:
        isa_eligible = min(isa_transfer_amount, 3_000_000)
        isa_extra_deduction = int(isa_eligible * 0.10)

    # 4단계: 세액공제 초과 납입 (과세이연만)
    excess_deposit = remaining  # 세액공제는 안 되지만 과세이연 효과

    # 결과 계산
    deductible_total = pension_saving + irp_deposit
    tax_refund = int(deductible_total * deduction_rate) + isa_extra_deduction

    return {
        "세액공제율": bracket,
        "연금저축_납입": f"{pension_saving:,}원",
        "IRP_납입": f"{irp_deposit:,}원",
        "세액공제_대상_합계": f"{deductible_total:,}원",
        "연말정산_환급액": f"{tax_refund:,}원",
        "ISA_추가공제": f"{isa_extra_deduction:,}원",
        "과세이연_추가납입": f"{excess_deposit:,}원",
    }


# 시나리오 비교
scenarios = [
    {"total_annual_saving": 9_000_000, "gross_salary": 40_000_000},
    {"total_annual_saving": 12_000_000, "gross_salary": 70_000_000},
    {"total_annual_saving": 18_000_000, "gross_salary": 50_000_000,
     "has_isa_maturity": True, "isa_transfer_amount": 3_000_000},
]

for i, s in enumerate(scenarios, 1):
    print(f"\n=== 시나리오 {i} ===")
    result = optimize_tax_deduction(**s)
    for k, v in result.items():
        print(f"  {k}: {v}")

from datetime import datetime, timedelta

def check_rebalance_trigger(
    current_weights: dict,
    target_weights: dict,
    threshold_pct: float = 5.0,
    last_rebalance_date: str = "2025-09-15",
    min_interval_days: int = 90,
) -> dict:
    """
    리밸런싱 트리거 판단
    - threshold_pct: 편차 기준 (기본 5%)
    - min_interval_days: 최소 리밸런싱 간격 (기본 90일)
    """
    today = datetime.now()
    last_date = datetime.strptime(last_rebalance_date, "%Y-%m-%d")
    days_since = (today - last_date).days
    time_ok = days_since >= min_interval_days

    deviations = {}
    trigger_assets = []

    for asset in target_weights:
        current = current_weights.get(asset, 0)
        target = target_weights[asset]
        deviation = current - target
        deviations[asset] = round(deviation, 2)
        if abs(deviation) >= threshold_pct:
            trigger_assets.append(asset)

    needs_rebalance = len(trigger_assets) > 0 and time_ok

    actions = {}
    if needs_rebalance:
        for asset in target_weights:
            diff = target_weights[asset] - current_weights.get(asset, 0)
            if abs(diff) >= 1.0:
                action = "매수" if diff > 0 else "매도"
                actions[asset] = f"{action} {abs(diff):.1f}%p"

    return {
        "날짜": today.strftime("%Y-%m-%d"),
        "마지막_리밸런싱": last_rebalance_date,
        "경과일": days_since,
        "최소간격_충족": time_ok,
        "편차": deviations,
        "기준초과_자산": trigger_assets,
        "리밸런싱_필요": needs_rebalance,
        "조정_액션": actions,
    }


# 예시: 40대 DC형 포트폴리오
target = {
    "해외주식": 40.0, "국내주식": 15.0, "배당ETF": 10.0,
    "국내채권": 25.0, "해외채권": 5.0, "금": 5.0,
}
current = {
    "해외주식": 47.2, "국내주식": 13.8, "배당ETF": 11.5,
    "국내채권": 20.1, "해외채권": 4.2, "금": 3.2,
}

result = check_rebalance_trigger(current, target)
for k, v in result.items():
    print(f"  {k}: {v}")

import numpy as np

def monte_carlo_retirement(
    current_age: int = 35,
    retire_age: int = 60,
    monthly_contribution: int = 750_000,  # 월 납입액 (원)
    initial_balance: int = 20_000_000,    # 현재 잔액 (원)
    equity_ratio_start: float = 0.70,     # 초기 주식 비중
    equity_ratio_end: float = 0.40,       # 은퇴 시 주식 비중
    equity_return: float = 0.08,          # 주식 기대수익률 (연)
    equity_vol: float = 0.18,             # 주식 변동성 (연)
    bond_return: float = 0.035,           # 채권 기대수익률 (연)
    bond_vol: float = 0.04,              # 채권 변동성 (연)
    inflation: float = 0.025,             # 기대 인플레이션
    n_simulations: int = 5000,
    target_amount: int = 500_000_000,     # 목표 은퇴자금 (원)
) -> dict:
    """몬테카를로 은퇴 자금 시뮬레이션"""
    years = retire_age - current_age
    months = years * 12

    np.random.seed(42)
    final_balances = []

    for _ in range(n_simulations):
        balance = initial_balance

        for month in range(months):
            year_progress = month / months
            # 글라이드패스 적용
            eq_ratio = equity_ratio_start - (
                equity_ratio_start - equity_ratio_end
            ) * year_progress
            bond_ratio = 1 - eq_ratio

            # 월간 수익률 시뮬레이션 (정규분포)
            eq_monthly_r = np.random.normal(
                equity_return / 12, equity_vol / np.sqrt(12)
            )
            bond_monthly_r = np.random.normal(
                bond_return / 12, bond_vol / np.sqrt(12)
            )

            portfolio_return = eq_ratio * eq_monthly_r + bond_ratio * bond_monthly_r
            balance = balance * (1 + portfolio_return) + monthly_contribution

        # 인플레이션 조정 (실질 가치)
        real_balance = balance / ((1 + inflation) ** years)
        final_balances.append(real_balance)

    final_balances = np.array(final_balances)
    success_rate = np.mean(final_balances >= target_amount) * 100

    return {
        "시뮬레이션_횟수": n_simulations,
        "투자_기간": f"{years}년",
        "월_납입액": f"{monthly_contribution:,}원",
        "목표_금액": f"{target_amount:,}원",
        "중위값(실질)": f"{int(np.median(final_balances)):,}원",
        "하위_10%(실질)": f"{int(np.percentile(final_balances, 10)):,}원",
        "상위_10%(실질)": f"{int(np.percentile(final_balances, 90)):,}원",
        "목표달성_확률": f"{success_rate:.1f}%",
        "최악_시나리오(실질)": f"{int(np.percentile(final_balances, 5)):,}원",
    }


# 35세, 월 75만 원 납입, 은퇴 목표 5억
result = monte_carlo_retirement()
print("=== 몬테카를로 은퇴 시뮬레이션 결과 ===")
for k, v in result.items():
    print(f"  {k}: {v}")