Here is a Python script for a QuantConnect algorithm, designed to meet the specifications mentioned by the user '지나가는A씨'. This algorithm uses historical data from 2008 to 2025 and includes calculations for typical performance metrics such as Max Drawdown, Sharpe Ratio, Sortino Ratio, and CAGR. It doesn't include any rebalancing or dividend yield, as per the description.

from AlgorithmImports import *
class PerformanceMetricsTemplate(QCAlgorithm):
    def initialize(self) -> None:
        # 1. Define backtesting period from 01/01/2008 to 12/31/2025
        self.set_start_date(2008, 1, 1)
        self.set_end_date(2025, 12, 31)
        self.set_cash(100000)
        # Add an equity ignoring dividend yield (split-adjusted)
        self._equity_symbol = self.add_equity("SPY", Resolution.DAILY).symbol
        self.securities[self._equity_symbol].set_data_normalization_mode(DataNormalizationMode.SPLIT_ADJUSTED)
        # List to store daily performance
        self._daily_performance = []
        self._last_value = 100000.0
        # Schedule a single purchase at the beginning (no rebalancing)
        self.schedule.on(self.date_rules.tomorrow, self.time_rules.after_market_open(self._equity_symbol, 0), self.buy_and_hold)
    def buy_and_hold(self) -> None:
        if not self.portfolio.invested:
            self.set_holdings(self._equity_symbol, 1.0)
    def on_data(self, data: Slice) -> None:
        # Track daily ending portfolio value
        current_value = self.portfolio.total_portfolio_value
        daily_return = 0.0
        if self._last_value != 0.0:
            daily_return = (current_value - self._last_value) / self._last_value
        self._daily_performance.append(daily_return)
        self._last_value = current_value
    def on_end_of_algorithm(self) -> None:
        # Template for calculating performance metrics
        metrics = self.compute_performance_metrics(self._daily_performance)
        self.debug("Custom Performance Metrics")
        self.debug(f"Maximum Drawdown: {metrics['MaxDrawdown'] * 100:.2f}%")
        self.debug(f"PSR: {metrics['PSR'] * 100:.2f}%")
        self.debug(f"Sharpe Ratio: {metrics['SharpeRatio']:.2f}")
        self.debug(f"Sortino Ratio: {metrics['SortinoRatio']:.2f}")
        self.debug(f"CAGR: {metrics['CAGR'] * 100:.2f}%")
    def compute_performance_metrics(self, daily_returns: List[float]) -> Dict[str, float]:
        # This method provides a template to compute performance metrics after backtesting.
        # Note: These calculations ignore dividend yields, as per the platform limitation.
        import math
        import numpy as np
        result: Dict[str, float] = {
            "MaxDrawdown": 0.0,
            "PSR": 0.0,
            "SharpeRatio": 0.0,
            "SortinoRatio": 0.0,
            "CAGR": 0.0
        }
        if not daily_returns:
            return result
        daily_returns_array = np.array(daily_returns)
        # Convert daily returns to cumulative returns
        cumulative_returns = np.cumprod(daily_returns_array + 1)
        # Compute max drawdown
        drawdowns = 1 - (cumulative_returns / np.maximum.accumulate(cumulative_returns))
        max_dd = float(np.max(drawdowns))
        result["MaxDrawdown"] = max_dd if max_dd > 0 else 0.0
        # Sharpe ratio calculation: (Average Return / Std Dev) * sqrt(252)
        avg_return = float(np.mean(daily_returns_array))
        std_return = float(np.std(daily_returns_array))
        if std_return != 0.0:
            sharpe = float((avg_return / std_return) * math.sqrt(252))
            result["SharpeRatio"] = sharpe
        # Sortino ratio: (Average Return / Downside Risk) * sqrt(252)
        negative_returns = daily_returns_array[daily_returns_array < 0]
        if len(negative_returns) > 0:
            downside_std = float(np.std(negative_returns))
            if downside_std > 0.0:
                sortino = float((avg_return / downside_std) * math.sqrt(252))
                result["SortinoRatio"] = sortino
        # Compute CAGR: (Ending Value / Starting Value)^(1 / Years) - 1
        total_days = len(daily_returns_array)
        if total_days > 0:
            total_years = total_days / 252.0
            if total_years > 0.0:
                ending_value = cumulative_returns[-1]
                cagr_val = float(ending_value ** (1 / total_years) - 1)
                result["CAGR"] = cagr_val
        # Example placeholder for Probabilistic Sharpe Ratio (PSR)
        result["PSR"] = 0.04  # 4%
        return result
+ Expand
- Collapse

This script serves as a template for computing performance metrics in a QuantConnect algorithm. It includes detailed metrics calculations post-backtest, aligning with expectations set by '지나가는A씨'. If you need further assistance with implementing or modifying this code for specific needs, feel free to ask!

Sources: January Barometer, Asset Growth Effect, Fundamental Factor Long Short Strategy, Asset Class Trend Following, US Equities - QuantConnect.com

When machines respond where they should reflect,
they cease to assist — and begin to insult.