Upload 27 files

Advance_version/backtester.py

@@ -0,0 +1,103 @@
+import pandas as pd
+import numpy as np
+import logging
+
+logger = logging.getLogger(__name__)
+class Backtester:
+    def __init__(self, trade_df: pd.DataFrame, costs: dict, volume: pd.DataFrame, ticker1: str, ticker2: str):
+        self.df = trade_df.copy()
+        self.fixed_cost = costs["fixed_per_trade"]
+        self.slip_coeff = costs["slippage_coefficient"]
+        self.volume = volume
+        self.ticker1 = ticker1
+        self.ticker2 = ticker2
+        self._prepare()
+
+
+    def _prepare(self):
+        """
+        1. Compute daily returns for each leg.
+        2. Align positions with returns (shift positions by 1 day to avoid look‐ahead).
+        3. Compute trades (where positions change).
+        """
+        self.df["ret1"] = self.df["price1"].pct_change().fillna(0)
+        self.df["ret2"] = self.df["price2"].pct_change().fillna(0)
+
+        # Shift positions to align with next day's pnl
+        self.df["pos1_lag"] = self.df["pos1"].shift(1).fillna(0)
+        self.df["pos2_lag"] = self.df["pos2"].shift(1).fillna(0)
+
+        # Identify when trades occur (pos changes)
+        self.df["trade1"] = (self.df["pos1"] != self.df["pos1_lag"]).astype(int)
+        self.df["trade2"] = (self.df["pos2"] != self.df["pos2_lag"]).astype(int)
+
+    def run(self) -> pd.DataFrame:
+        """
+        Compute P&L step by step:
+          1) Gross P&L: pos_lag * returns
+          2) Subtract transaction costs when trade occurs:
+             fixed cost + slippage based on ADV
+        Returns a DataFrame augmented with P&L columns.
+        """
+        df = self.df.copy()
+
+        # 1) Gross P&L (as fraction of capital)
+        df["pnl1"] = df["pos1_lag"] * df["ret1"]
+        df["pnl2"] = df["pos2_lag"] * df["ret2"]
+        df["gross_pnl"] = df["pnl1"] + df["pnl2"]
+
+        # 2) Transaction costs
+        # For each trade, cost = fixed + slippage_coefficient * (notional / ADV)
+        # Approx ADV: use prev day's volume * price
+        adv1 = self.volume[self.ticker1].shift(1) * df["price1"].shift(1)
+        adv2 = self.volume[self.ticker2].shift(1) * df["price2"].shift(1)
+
+        # Avoid division by zero
+        adv1 = adv1.replace(0, np.nan).fillna(method="ffill").fillna(1e6)
+        adv2 = adv2.replace(0, np.nan).fillna(method="ffill").fillna(1e6)
+
+        df["slip1"] = (
+            self.slip_coeff * (abs(df["pos1"] - df["pos1_lag"]) * df["price1"]) 
+            / adv1
+        )
+        df["slip2"] = (
+            self.slip_coeff * (abs(df["pos2"] - df["pos2_lag"]) * df["price2"]) 
+            / adv2
+        )
+
+        df["trans_cost1"] = df["trade1"] * (self.fixed_cost + df["slip1"])
+        df["trans_cost2"] = df["trade2"] * (self.fixed_cost + df["slip2"])
+        df["total_tc"] = df["trans_cost1"] + df["trans_cost2"]
+
+        # 3) Net P&L
+        df["net_pnl"] = df["gross_pnl"] - df["total_tc"]
+
+        # 4) Cumulative returns
+        df["strategy_return"] = df["net_pnl"]
+        df["cum_return"] = (1 + df["strategy_return"]).cumprod() - 1
+
+        logger.info("Backtest run completed.")
+        return df
+
+    def performance_metrics(self, df: pd.DataFrame) -> dict:
+        """
+        Compute standard metrics: Sharpe, annualized return, max drawdown.
+        :return: dict of metrics.
+        """
+        returns = df["strategy_return"].fillna(0)
+        ann_return = (1 + returns).prod() ** (252 / len(returns)) - 1
+        ann_vol = returns.std() * np.sqrt(252)
+        sharpe = ann_return / ann_vol if ann_vol != 0 else np.nan
+
+        # Max drawdown
+        cum = (1 + returns).cumprod()
+        peak = cum.cummax()
+        drawdown = (cum - peak) / peak
+        max_dd = drawdown.min()
+
+        return {
+            "annual_return": ann_return,
+            "annual_vol": ann_vol,
+            "sharpe": sharpe,
+            "max_drawdown": max_dd
+        }

Advance_version/config.yaml

@@ -0,0 +1,82 @@
+# ===========================
+# Data Loader Settings
+# ===========================
+data:
+  tickers:               # List of tickers to consider in universe
+    - "3N4.SG"
+    - "CUBEXTUB.NS"
+    - "JIX.F"
+    - "HINDCOPPER.NS"
+    - "SARKY.IS"
+    - "RE8.F"
+    - "BHAGYANGR.NS"
+    - "FDY.TO"
+    - "9CM0.F"
+    - "GRX.AX"
+    - "ARREF"
+    - "MTJ3.F"
+    - "GRX.L"
+    - "005810.KS"
+    - "2009.TW"
+    - "OUW0.F"
+    - "CS.TO"
+    - "SFR.AX"
+    - "PUCOBRE.SN"
+    - "ATYM.L"
+
+  start_date: "2021-01-01"
+  end_date:   "2025-07-01"
+  interval:   "1d"        # "1d", "5m", etc.
+
+# ===========================
+# Pair Selector Settings
+# ===========================
+pair_selector:
+  cluster_size: 20        # approx. number of tickers per cluster
+  coint_pval_threshold: 0.05
+  rolling_window: 252     # days for rolling cointegration
+  rolling_step: 63        # days per step
+  min_valid_periods: 2    # consecutive windows required
+
+# ===========================
+# Kalman Hedge Settings
+# ===========================
+kalman:
+  initial_state_cov: [[1e-4, 0], [0, 1e-4]]  # small prior covariance for intercept & beta
+  transition_cov:   [[1e-5, 0], [0, 1e-5]]  # process noise; EM will refine
+  observation_cov:  1e-3                    # observation noise; EM will refine
+  em_iterations:    20
+
+# ===========================
+# Signal Generator Settings
+# ===========================
+signal:
+  zscore_window: 20      # rolling window for spread mean/std
+  entry_z: 2.0           # base z-score for entry (will scale by vol)
+  exit_z: 0.5            # base z-score for exit
+  target_vol: 0.001      # target daily vol of spread (10 bps)
+  min_vol_percentile: 30 # only trade if spread vol rank < 30th percentile
+  momentum_filter: true  # require spread momentum to point back to mean
+
+# ===========================
+# Transaction Cost Settings
+# ===========================
+costs:
+  fixed_per_trade: 0.000   # $0.005 per share
+  slippage_coefficient: 0.0000  # 1 bp slippage per 0.1% of ADV
+
+# ===========================
+# Risk Engine Settings
+# ===========================
+risk:
+  daily_var_window: 252
+  var_confidence: 0.95
+  max_drawdown_limit: 0.02   # 2% per day (hard stop)
+  worst_pair_dd: 0.05        # drop pair if drawdown > 5%
+
+# ===========================
+# Portfolio Optimizer Settings
+# ===========================
+portfolio:
+  min_weight: 0.0
+  max_weight: 0.1          # no single pair >10% of capital

Advance_version/data_loader.py

@@ -0,0 +1,72 @@
+import pandas as pd
+import yfinance as yf
+import logging
+from typing import List, Tuple
+
+logger = logging.getLogger(__name__)
+
+class DataLoader:
+    """
+    Fetches and preprocesses price (and volume) data for a given universe.
+    Supports daily and intraday via yfinance.
+    """
+
+    def __init__(self, tickers: List[str], start_date: str, end_date: str, interval: str = "1d"):
+        """
+        :param tickers: List of ticker strings.
+        :param start_date: "YYYY-MM-DD"
+        :param end_date:   "YYYY-MM-DD"
+        :param interval:   "1d", "5m", etc.
+        """
+        self.tickers = tickers
+        self.start_date = start_date
+        self.end_date = end_date
+        self.interval = interval
+
+    def fetch_data(self) -> Tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Downloads Adj Close and Volume for all tickers between start_date and end_date.
+        :return: Tuple (prices_df, volume_df). Both are DataFrames with datetime index.
+        """
+        logger.info(f"Fetching data for {len(self.tickers)} tickers from {self.start_date} to {self.end_date} at interval {self.interval}.")
+
+        raw = yf.download(
+            tickers=self.tickers,
+            start=self.start_date,
+            end=self.end_date,
+            interval=self.interval,
+            auto_adjust=True,
+            progress=False
+        )
+
+        if raw.empty:
+            logger.error("No data fetched. Please check your tickers and date range.")
+            raise ValueError("Empty pricing data.")
+
+        # yfinance returns a MultiIndex with (Attribute, Ticker)
+        # We extract 'Close' (adjusted) and 'Volume'.
+        if "Close" in raw and "Volume" in raw:
+            prices = raw["Close"].copy()
+            volume = raw["Volume"].copy()
+        else:
+            # For some intervals, yfinance may label adjusted close as 'Adj Close'
+            if "Adj Close" in raw and "Volume" in raw:
+                prices = raw["Adj Close"].copy()
+                volume = raw["Volume"].copy()
+            else:
+                logger.error("Unexpected data format from yfinance.")
+                raise ValueError("Unexpected data format.")
+
+        # Drop rows where any ticker is missing (to align)
+        combined = pd.concat([prices, volume], axis=1, keys=["price", "volume"])
+        combined = combined.dropna()
+        prices = combined["price"]
+        volume = combined["volume"]
+
+        # Ensure columns are sorted alphabetically for consistency
+        prices = prices.sort_index(axis=1)
+        volume = volume[prices.columns]
+
+        logger.info(f"Downloaded price data with shape {prices.shape}, volume data with shape {volume.shape}.")
+        return prices, volume
+

Advance_version/execution_engine.py

@@ -0,0 +1,35 @@
+import numpy as np
+import pandas as pd
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ExecutionEngine:
+    """
+    Models realistic slippage based on notional vs. ADV.
+    """
+
+    def __init__(self, slippage_coefficient: float):
+        """
+        :param slippage_coefficient: e.g., 0.0001 (1 bp per 0.1% ADV)
+        """
+        self.slip_coeff = slippage_coefficient
+
+    def compute_slippage(
+        self,
+        notional: pd.Series,
+        volume: pd.Series,
+        price: pd.Series
+    ) -> pd.Series:
+        """
+        Computes slippage cost = slip_coeff * (notional / (ADV * price)).
+        :param notional: Series of absolute dollar notional traded.
+        :param volume: Series of share volume (ADV proxy).
+        :param price:  Series of price to convert volume to ADV notional.
+        :return: Series of slippage costs (as fraction of capital).
+        """
+        # ADV dollar volume
+        adv_dollar = volume * price
+        adv_dollar = adv_dollar.replace(0, np.nan).fillna(method="ffill").fillna(1e9)
+        slip = self.slip_coeff * (notional / adv_dollar)
+        return slip

Advance_version/kalman_hedge.py

@@ -0,0 +1,144 @@
+import numpy as np
+import pandas as pd
+from pykalman import KalmanFilter
+import logging
+from typing import Tuple
+
+logger = logging.getLogger(__name__)
+
+class KalmanHedge:
+    """
+    Runs a Kalman filter with an intercept and time‐varying hedge ratio (beta).
+    Allows EM estimation of Q and R.
+    """
+
+    def __init__(
+        self,
+        observation_series: pd.Series,
+        control_series: pd.Series,
+        initial_state_cov: np.ndarray,
+        transition_cov: np.ndarray,
+        observation_cov: float,
+        em_iterations: int = 20
+    ):
+        """
+        :param observation_series: Y_t series (e.g., prices of ticker1).
+        :param control_series:     X_t series (e.g., prices of ticker2).
+        :param initial_state_cov:  2×2 covariance for [alpha, beta].
+        :param transition_cov:     2×2 process noise for [alpha, beta].
+        :param observation_cov:    scalar observation noise variance.
+        :param em_iterations:      number of EM iterations to refine Q & R.
+        """
+        # 强制数据为float类型
+        self.y = observation_series.astype(float).values
+        self.x = control_series.astype(float).values
+        self.dates = observation_series.index
+        self.initial_state_cov = np.array(initial_state_cov, dtype=float)
+        self.transition_cov = np.array(transition_cov, dtype=float)
+        self.observation_cov = float(observation_cov)
+        self.em_iterations = em_iterations
+
+        # Prepare structures to store results
+        n_points = len(self.y)
+        self.alpha = np.zeros(n_points)
+        self.beta = np.zeros(n_points)
+        self.spread = np.zeros(n_points)
+        self.state_covariances = np.zeros((n_points, 2, 2))
+
+        # Build the KalmanFilter object
+        self._build_filter()
+
+    def _build_filter(self):
+        """
+        Initializes a KalmanFilter with a 2D state: [alpha_t, beta_t].
+        Observation: y_t = [1, x_t] ⋅ [alpha_t, beta_t] + ε_t
+        State Evolution: [alpha_t, beta_t] = [alpha_{t-1}, beta_{t-1}] + η_t
+        """
+        n_timesteps = len(self.y)
+        # Transition matrix: identity (random walk for alpha & beta)
+        transition_matrices = np.eye(2, dtype=float)
+
+        # Observation matrices: time-varying (每步都不同)
+        observation_matrices = np.zeros((n_timesteps, 1, 2), dtype=float)
+        for t in range(n_timesteps):
+            observation_matrices[t, 0, 0] = 1.0
+            observation_matrices[t, 0, 1] = self.x[t]
+
+        initial_state_mean = np.zeros(2, dtype=float)
+        initial_state_covariance = self.initial_state_cov
+
+        self.kf = KalmanFilter(
+            transition_matrices=transition_matrices,
+            observation_matrices=observation_matrices,
+            initial_state_mean=initial_state_mean,
+            initial_state_covariance=initial_state_covariance,
+            transition_covariance=self.transition_cov,
+            observation_covariance=self.observation_cov
+        )
+
+        # Run EM to refine Q & R
+        try:
+            self.kf = self.kf.em(
+                X=None,
+                n_iter=self.em_iterations,
+                em_vars=["transition_covariance", "observation_covariance"]
+            )
+            logger.info("Kalman EM converged: Q and R estimated.")
+        except Exception as e:
+            logger.warning(f"Kalman EM failed or was skipped: {e}")
+
+    def run_filter(self):
+        """
+        Kalman filter main loop (predict-update per time step).
+        At each step t:
+          1. Predict next state, using transition_matrix。
+          2. Compute spread_t = y_t - [alpha_{t|t-1} + beta_{t|t-1} * x_t]
+          3. Update with observation y_t and correct observation_matrix.
+        """
+        n = len(self.y)
+        state_mean = np.zeros((n, 2), dtype=float)
+        state_cov = np.zeros((n, 2, 2), dtype=float)
+
+        state_mean[0] = self.kf.initial_state_mean
+        state_cov[0] = self.kf.initial_state_covariance
+
+        for t in range(1, n):
+            # 预测（仅给出本步观测矩阵！——很重要）
+            mean_pred, cov_pred = self.kf.filter_update(
+                filtered_state_mean=state_mean[t - 1],
+                filtered_state_covariance=state_cov[t - 1],
+                observation=None,
+                # 必须指定 observation_matrix，每步都要
+                observation_matrix=self.kf.observation_matrices[t]
+            )
+
+            # 用预测state计算spread
+            a_pred, b_pred = mean_pred
+            self.spread[t] = self.y[t] - (a_pred + b_pred * self.x[t])
+
+            # 更新
+            mean_filt, cov_filt = self.kf.filter_update(
+                filtered_state_mean=mean_pred,
+                filtered_state_covariance=cov_pred,
+                observation=self.y[t],
+                observation_matrix=self.kf.observation_matrices[t]
+            )
+            state_mean[t] = mean_filt
+            state_cov[t] = cov_filt
+            self.alpha[t] = mean_filt[0]
+            self.beta[t] = mean_filt[1]
+            self.state_covariances[t] = cov_filt
+
+        # 初始点
+        self.spread[0] = self.y[0] - (state_mean[0][0] + state_mean[0][1] * self.x[0])
+        self.alpha[0] = state_mean[0][0]
+        self.beta[0] = state_mean[0][1]
+        self.state_covariances[0] = state_cov[0]
+
+        result = pd.DataFrame({
+            "alpha": self.alpha,
+            "beta": self.beta,
+            "spread": self.spread
+        }, index=self.dates)
+        logger.info("Kalman filter run completed.")
+        return result

Advance_version/logger.py

@@ -0,0 +1,20 @@
+import logging
+import sys
+
+def setup_logger(name: str) -> logging.Logger:
+    """
+    Sets up a root logger with INFO level, console handler,
+    and a consistent formatting style.
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+    if not logger.handlers:
+        ch = logging.StreamHandler(sys.stdout)
+        ch.setLevel(logging.INFO)
+        formatter = logging.Formatter(
+            "%(asctime)s | %(name)s | %(levelname)s | %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S"
+        )
+        ch.setFormatter(formatter)
+        logger.addHandler(ch)
+    return logger

Advance_version/pair_selector.py

@@ -0,0 +1,91 @@
+import pandas as pd
+import numpy as np
+import itertools
+import logging
+from utils import cluster_universe, rolling_cointegration_test, half_life
+
+logger = logging.getLogger(__name__)
+
+class PairSelector:
+    """
+    From a universe of assets, cluster similar ones, then within each cluster 
+    run rolling cointegration tests. For stable pairs, compute static hedge ratio 
+    via OLS and half‐life of the spread.
+    """
+
+    def __init__(
+        self,
+        prices: pd.DataFrame,
+        cluster_size: int = 20,
+        coint_pval_threshold: float = 0.05,
+        rolling_window: int = 252,
+        rolling_step: int = 63,
+        min_valid_periods: int = 2
+    ):
+        """
+        :param prices: DataFrame of asset prices (aligned), columns = tickers.
+        """
+        self.prices = prices
+        self.returns = prices.pct_change().dropna()
+        self.cluster_size = cluster_size
+        self.pval_threshold = coint_pval_threshold
+        self.rolling_window = rolling_window
+        self.rolling_step = rolling_step
+        self.min_valid_periods = min_valid_periods
+
+    def select_pairs(self) -> pd.DataFrame:
+        """
+        Returns a DataFrame with columns: [ticker1, ticker2, beta_ols, half_life_days].
+        Only includes pairs that pass the rolling cointegration test.
+        """
+        # 1) Cluster the universe
+        clusters = cluster_universe(self.returns, self.cluster_size)
+
+        selected = []
+        for cluster_id, tickers in clusters.items():
+            if len(tickers) < 2:
+                continue
+            logger.info(f"Testing cluster {cluster_id} with {len(tickers)} tickers.")
+            # For each unique pair in that cluster:
+            for t1, t2 in itertools.combinations(tickers, 2):
+                s1 = self.prices[t1]
+                s2 = self.prices[t2]
+                # 2) Rolling cointegration test
+                try:
+                    is_coint = rolling_cointegration_test(
+                        s1, s2,
+                        window=self.rolling_window,
+                        step=self.rolling_step,
+                        pval_threshold=self.pval_threshold,
+                        min_valid_periods=self.min_valid_periods
+                    )
+                except Exception as e:
+                    logger.warning(f"Cointegration test failed for {t1}-{t2}: {e}")
+                    continue
+
+                if not is_coint:
+                    continue
+
+                # 3) Compute static OLS hedge ratio on full period
+                # Solve s1 = alpha + beta*s2 + eps
+                X = np.vstack([np.ones(len(s2)), s2.values]).T
+                y = s1.values
+                ols_beta = np.linalg.lstsq(X, y, rcond=None)[0][1]
+
+                # 4) Compute half-life of spread
+                spread = s1 - ols_beta * s2
+                hl = half_life(spread)
+
+                # 5) Save if half-life is finite and reasonable (< window)
+                if np.isfinite(hl) and hl > 0 and hl < self.rolling_window:
+                    selected.append({
+                        "ticker1": t1,
+                        "ticker2": t2,
+                        "beta_ols": ols_beta,
+                        "half_life": hl
+                    })
+                    logger.info(f"Selected pair {t1}-{t2}: beta={ols_beta:.4f}, half-life={hl:.1f} days.")
+        if not selected:
+            logger.warning("No cointegrated pairs found in the universe.")
+            return pd.DataFrame(columns=["ticker1", "ticker2", "beta_ols", "half_life"])
+        return pd.DataFrame(selected)

Advance_version/portfolio_optimizer.py

@@ -0,0 +1,57 @@
+import numpy as np
+import pandas as pd
+import cvxpy as cp
+import logging
+
+logger = logging.getLogger(__name__)
+
+class PortfolioOptimizer:
+    """
+    Given a DataFrame of pair‐level returns (columns = pair names, rows = dates),
+    solves a minimum‐variance allocation (or any convex objective).
+    """
+
+    def __init__(
+        self,
+        pair_returns: pd.DataFrame,
+        min_weight: float = 0.0,
+        max_weight: float = 0.1
+    ):
+        """
+        :param pair_returns: DataFrame (T×N) of returns for N pairs.
+        :param min_weight: lower bound for each weight.
+        :param max_weight: upper bound for each weight.
+        """
+        self.returns = pair_returns.dropna(how="all")
+        self.N = self.returns.shape[1]
+        self.min_w = min_weight
+        self.max_w = max_weight
+
+    def min_variance(self) -> pd.Series:
+        """
+        Solve: minimize wᵀ Σ w subject to ∑w = 1, and min_w ≤ w_i ≤ max_w.
+        Returns a Series of weights indexed by pair names.
+        """
+        cov = self.returns.cov().values
+        cov += np.eye(self.N) * 1e-6
+
+        w = cp.Variable(self.N)
+        objective = cp.Minimize(cp.quad_form(w, cov))
+        constraints = [
+            cp.sum(w) == 1,
+            w >= self.min_w,
+            w <= self.max_w
+        ]
+        prob = cp.Problem(objective, constraints)
+        prob.solve(solver=cp.OSQP, verbose=False)
+
+        if w.value is None:
+            logger.error("Portfolio optimization failed.")
+            # Fallback: equal weights
+            w_opt = np.ones(self.N) / self.N
+        else:
+            w_opt = w.value
+
+        weights = pd.Series(w_opt, index=self.returns.columns)
+        logger.info(f"Min‐variance weights computed: {weights.to_dict()}")
+        return weights

Advance_version/risk_engine.py

@@ -0,0 +1,93 @@
+import pandas as pd
+import numpy as np
+import logging
+from scipy.stats import norm
+
+logger = logging.getLogger(__name__)
+
+class RiskEngine:
+    """
+    Computes risk metrics for a strategy or portfolio of pair returns.
+    Includes VaR (historical and parametric), max drawdown, and 
+    placeholder for factor neutrality/regression.
+    """
+
+    def __init__(self, returns: pd.Series, config: dict):
+        """
+        :param returns: Series of daily strategy returns.
+        :param config: dict under key 'risk' from config.yaml.
+        """
+        self.returns = returns.dropna()
+        self.daily_var_window = config["daily_var_window"]
+        self.var_conf = config["var_confidence"]
+        self.max_dd_limit = config["max_drawdown_limit"]
+
+    def historical_var(self) -> float:
+        """
+        Historical VaR at confidence level.
+        """
+        window = min(self.daily_var_window, len(self.returns))
+        hist = self.returns.tail(window)
+        var_h = np.percentile(hist, (1 - self.var_conf) * 100)
+        logger.info(f"Historical VaR (window={window}, conf={self.var_conf}) = {var_h:.4%}")
+        return var_h
+
+    def parametric_var(self) -> float:
+        """
+        Parametric VaR assuming normality.
+        """
+        mean = self.returns.mean()
+        std = self.returns.std()
+        var_p = mean + std * norm.ppf(1 - self.var_conf)
+        logger.info(f"Parametric VaR (conf={self.var_conf}) = {var_p:.4%}")
+        return var_p
+
+    def max_drawdown(self) -> float:
+        """
+        Compute maximum drawdown.
+        """
+        cum = (1 + self.returns).cumprod()
+        peak = cum.cummax()
+        drawdown = (cum - peak) / peak
+        max_dd = drawdown.min()
+        logger.info(f"Maximum drawdown = {max_dd:.4%}")
+        return max_dd
+
+    def check_hard_limits(self) -> dict:
+        """
+        Checks if current drawdown or VaR breaches the configured limits.
+        """
+        dd = self.max_drawdown()
+        var_h = self.historical_var()
+        alerts = {}
+        if abs(dd) > self.max_dd_limit:
+            alerts["drawdown_breach"] = dd
+        if var_h < -self.max_dd_limit:
+            alerts["var_breach"] = var_h
+        return alerts
+
+    def stress_test_returns(self, stress_scenario: pd.Series) -> float:
+        """
+        Given a stress scenario of returns (Series aligned by date or simply 
+        a vector of % shocks), compute expected P&L under that stress.
+        For simplicity, sum elementwise product with strategy exposure = 1.
+        """
+        # This is a placeholder: user should supply a scenario vector.
+        pnl = (self.returns * stress_scenario).sum()
+        logger.info(f"Stress test scenario P&L = {pnl:.4f}")
+        return pnl
+
+    def factor_neutrality(self, factor_returns: pd.DataFrame) -> dict:
+        """
+        Regress strategy returns on supplied factor returns to compute
+        betas and R². Returns a dict of factor exposures.
+        """
+        import statsmodels.api as sm
+
+        X = sm.add_constant(factor_returns.loc[self.returns.index])
+        y = self.returns
+        model = sm.OLS(y, X).fit()
+        exposures = model.params.to_dict()
+        r2 = model.rsquared
+        logger.info(f"Factor regression R² = {r2:.4f}, exposures = {exposures}")
+        return {"exposures": exposures, "r2": r2}

Advance_version/run_backtest.py

@@ -0,0 +1,189 @@
+import yaml
+import os
+import logging
+import pandas as pd
+from logger import setup_logger
+
+# Import modules
+from data_loader import DataLoader
+from pair_selector import PairSelector
+from kalman_hedge import KalmanHedge
+from signal_generator import SignalGenerator
+from backtester import Backtester
+from risk_engine import RiskEngine
+from portfolio_optimizer import PortfolioOptimizer
+
+# Set up root logger
+logger = setup_logger("PairTradingStrategy")
+
+def load_config(path: str) -> dict:
+    with open(path, "r") as f:
+        cfg = yaml.safe_load(f)
+    return cfg
+
+def calc_portfolio_metrics(returns):
+    returns = returns.fillna(0)
+    ann_return = (1 + returns).prod() ** (252 / len(returns)) - 1
+    ann_vol = returns.std() * (252 ** 0.5)
+    sharpe = ann_return / ann_vol if ann_vol != 0 else float("nan")
+    cum = (1 + returns).cumprod()
+    peak = cum.cummax()
+    drawdown = (cum - peak) / peak
+    max_dd = drawdown.min()
+    return {
+        "annual_return": ann_return,
+        "annual_vol": ann_vol,
+        "sharpe": sharpe,
+        "max_drawdown": max_dd,
+    }
+
+def main():
+    # 1) Load configuration
+    config_path = os.path.join(os.path.dirname(__file__), "../config.yaml")
+    cfg = load_config(config_path)
+    logger.info("Configuration loaded.")
+
+    # 2) Fetch data
+    data_cfg = cfg["data"]
+    dl = DataLoader(
+        tickers=data_cfg["tickers"],
+        start_date=data_cfg["start_date"],
+        end_date=data_cfg["end_date"],
+        interval=data_cfg["interval"]
+    )
+    prices, volume = dl.fetch_data()
+
+    # 3) Select pairs
+    ps_cfg = cfg["pair_selector"]
+    pair_selector = PairSelector(
+        prices=prices,
+        cluster_size=ps_cfg["cluster_size"],
+        coint_pval_threshold=ps_cfg["coint_pval_threshold"],
+        rolling_window=ps_cfg["rolling_window"],
+        rolling_step=ps_cfg["rolling_step"],
+        min_valid_periods=ps_cfg["min_valid_periods"]
+    )
+    pairs_df = pair_selector.select_pairs()
+    if pairs_df.empty:
+        logger.error("No suitable pairs found. Exiting.")
+        return
+    logger.info(f"Number of selected pairs: {len(pairs_df)}")
+
+    # 4) For each selected pair, run Kalman hedge, generate signals, backtest
+    all_pair_returns = {}
+    results_summary = []
+    for idx, row in pairs_df.iterrows():
+        t1 = row["ticker1"]
+        t2 = row["ticker2"]
+        logger.info(f"Processing pair {t1}-{t2}.")
+
+        s1 = prices[t1]
+        s2 = prices[t2]
+
+        # 4a) Kalman hedge
+        km_cfg = cfg["kalman"]
+        kh = KalmanHedge(
+            observation_series=s1,
+            control_series=s2,
+            initial_state_cov=km_cfg["initial_state_cov"],
+            transition_cov=km_cfg["transition_cov"],
+            observation_cov=km_cfg["observation_cov"],
+            em_iterations=km_cfg["em_iterations"]
+        )
+        kalman_df = kh.run_filter()
+
+        # 4b) Signal generation
+        sig_cfg = cfg["signal"]
+        sg = SignalGenerator(
+            price1=s1,
+            price2=s2,
+            kalman_df=kalman_df,
+            config=sig_cfg
+        )
+        trade_df = sg.generate(costs=cfg["costs"], volume=volume[[t1, t2]])
+
+        # 4c) Backtest
+        bt = Backtester(
+            trade_df=trade_df,
+            costs=cfg["costs"],
+            volume=volume[[t1, t2]],
+            ticker1=t1,
+            ticker2=t2,
+        )
+        bt_results = bt.run()
+        metrics = bt.performance_metrics(bt_results)
+        logger.info(f"Pair {t1}-{t2} metrics: {metrics}")
+
+        # Store returns series for portfolio optimization
+        all_pair_returns[f"{t1}/{t2}"] = bt_results["strategy_return"]
+
+        # Summarize
+        results_summary.append({
+            "pair": f"{t1}/{t2}",
+            **metrics,
+            "half_life": row["half_life"]
+        })
+
+    # 5) Aggregate pair returns into DataFrame
+    pair_returns_df = (
+        pd.DataFrame(all_pair_returns)
+        .dropna(how="all")
+    )
+
+    # 6) Save pair_summary.csv
+    summary_df = pd.DataFrame(results_summary)
+    output_dir = os.path.join(os.path.dirname(__file__), "../output")
+    os.makedirs(output_dir, exist_ok=True)
+    summary_path = os.path.join(output_dir, "pair_summary.csv")
+    summary_df.to_csv(summary_path, index=False)
+    logger.info(f"Saved pair summary to {summary_path}.")
+
+    # ====== 选取 Sharpe > 0 的配对 ======
+    selected_pairs = summary_df[summary_df["sharpe"] > 0]["pair"].tolist()
+    if not selected_pairs:
+        logger.warning("No pairs with Sharpe > 0 were found. Portfolio will not be constructed.")
+        return
+    pair_returns_df_selected = pair_returns_df[selected_pairs]
+    logger.info(f"Selected pairs with Sharpe > 0: {selected_pairs}")
+
+    # 7) Portfolio optimization只用Sharpe>0的pair
+    port_cfg = cfg["portfolio"]
+    po = PortfolioOptimizer(
+        pair_returns=pair_returns_df_selected,
+        min_weight=port_cfg["min_weight"],
+        max_weight=port_cfg["max_weight"]
+    )
+    weights = po.min_variance()
+
+    # 8) Compute portfolio P&L
+    portfolio_ret = (pair_returns_df_selected * weights).sum(axis=1)
+    re = RiskEngine(returns=portfolio_ret, config=cfg["risk"])
+    var_h = re.historical_var()
+    var_p = re.parametric_var()
+    max_dd = re.max_drawdown()
+    logger.info(f"Portfolio VaR (hist) = {var_h:.4%}, (param) = {var_p:.4%}, max DD = {max_dd:.4%}")
+
+    # 9) 计算并输出整体组合绩效
+    portfolio_metrics = calc_portfolio_metrics(portfolio_ret)
+    logger.info(
+        f"Portfolio annual_return={portfolio_metrics['annual_return']:.4%}, "
+        f"annual_vol={portfolio_metrics['annual_vol']:.4%}, "
+        f"sharpe={portfolio_metrics['sharpe']:.2f}, "
+        f"max_drawdown={portfolio_metrics['max_drawdown']:.2%}"
+    )
+
+    # 10) 保存 portfolio_weights.csv 和 portfolio_metrics.csv
+    weights_path = os.path.join(output_dir, "portfolio_weights.csv")
+    weights.to_csv(weights_path, header=True)
+    logger.info(f"Saved portfolio weights to {weights_path}.")
+
+    pd.DataFrame([portfolio_metrics]).to_csv(
+        os.path.join(output_dir, "portfolio_metrics.csv"),
+        index=False
+    )
+    logger.info(f"Saved portfolio metrics to {os.path.join(output_dir, 'portfolio_metrics.csv')}.")
+
+    logger.info("Backtest pipeline completed successfully.")
+
+if __name__ == "__main__":
+    main()

Advance_version/scripts/run_backtest.py

@@ -0,0 +1,147 @@
+import yaml
+import os
+import logging
+from logger import setup_logger
+
+# Import modules
+from data_loader import DataLoader
+from pair_selector import PairSelector
+from kalman_hedge import KalmanHedge
+from signal_generator import SignalGenerator
+from backtester import Backtester
+from risk_engine import RiskEngine
+from portfolio_optimizer import PortfolioOptimizer
+
+# Set up root logger
+logger = setup_logger("PairTradingStrategy")
+
+def load_config(path: str) -> dict:
+    with open(path, "r") as f:
+        cfg = yaml.safe_load(f)
+    return cfg
+
+def main():
+    # 1) Load configuration
+    config_path = os.path.join(os.path.dirname(__file__), "../config.yaml")
+    cfg = load_config(config_path)
+    logger.info("Configuration loaded.")
+
+    # 2) Fetch data
+    data_cfg = cfg["data"]
+    dl = DataLoader(
+        tickers=data_cfg["tickers"],
+        start_date=data_cfg["start_date"],
+        end_date=data_cfg["end_date"],
+        interval=data_cfg["interval"]
+    )
+    prices, volume = dl.fetch_data()
+
+    # 3) Select pairs
+    ps_cfg = cfg["pair_selector"]
+    pair_selector = PairSelector(
+        prices=prices,
+        cluster_size=ps_cfg["cluster_size"],
+        coint_pval_threshold=ps_cfg["coint_pval_threshold"],
+        rolling_window=ps_cfg["rolling_window"],
+        rolling_step=ps_cfg["rolling_step"],
+        min_valid_periods=ps_cfg["min_valid_periods"]
+    )
+    pairs_df = pair_selector.select_pairs()
+    if pairs_df.empty:
+        logger.error("No suitable pairs found. Exiting.")
+        return
+    logger.info(f"Number of selected pairs: {len(pairs_df)}")
+
+    # 4) For each selected pair, run Kalman hedge, generate signals, backtest
+    all_pair_returns = {}
+    results_summary = []
+    for idx, row in pairs_df.iterrows():
+        t1 = row["ticker1"]
+        t2 = row["ticker2"]
+        logger.info(f"Processing pair {t1}-{t2}.")
+
+        s1 = prices[t1]
+        s2 = prices[t2]
+
+        # 4a) Kalman hedge
+        km_cfg = cfg["kalman"]
+        kh = KalmanHedge(
+            observation_series=s1,
+            control_series=s2,
+            initial_state_cov=km_cfg["initial_state_cov"],
+            transition_cov=km_cfg["transition_cov"],
+            observation_cov=km_cfg["observation_cov"],
+            em_iterations=km_cfg["em_iterations"]
+        )
+        kalman_df = kh.run_filter()
+
+        # 4b) Signal generation
+        sig_cfg = cfg["signal"]
+        sg = SignalGenerator(
+            price1=s1,
+            price2=s2,
+            kalman_df=kalman_df,
+            config=sig_cfg
+        )
+        trade_df = sg.generate(costs=cfg["costs"], volume=volume[[t1, t2]])
+
+        # 4c) Backtest
+        bt = Backtester(
+            trade_df=trade_df.rename(columns={"pos1": t1 + "_pos", "pos2": t2 + "_pos", 
+                                               "price1": t1 + "_price", "price2": t2 + "_price"}),
+            costs=cfg["costs"],
+            volume=volume[[t1, t2]].rename(columns={t1: t1 + "_vol", t2: t2 + "_vol"})
+        )
+        bt_results = bt.run()
+        metrics = bt.performance_metrics(bt_results)
+        logger.info(f"Pair {t1}-{t2} metrics: {metrics}")
+
+        # Store returns series for portfolio optimization
+        all_pair_returns[f"{t1}/{t2}"] = bt_results["strategy_return"]
+
+        # Summarize
+        results_summary.append({
+            "pair": f"{t1}/{t2}",
+            **metrics,
+            "half_life": row["half_life"]
+        })
+
+    # 5) Aggregate pair returns into DataFrame
+    pair_returns_df = (
+        pd.DataFrame(all_pair_returns)
+        .dropna(how="all")
+    )
+
+    # 6) Portfolio optimization
+    port_cfg = cfg["portfolio"]
+    po = PortfolioOptimizer(
+        pair_returns=pair_returns_df,
+        min_weight=port_cfg["min_weight"],
+        max_weight=port_cfg["max_weight"]
+    )
+    weights = po.min_variance()
+
+    # 7) Compute portfolio P&L
+    portfolio_ret = (pair_returns_df * weights).sum(axis=1)
+    re = RiskEngine(returns=portfolio_ret, config=cfg["risk"])
+    var_h = re.historical_var()
+    var_p = re.parametric_var()
+    max_dd = re.max_drawdown()
+    logger.info(f"Portfolio VaR (hist) = {var_h:.4%}, (param) = {var_p:.4%}, max DD = {max_dd:.4%}")
+
+    # 8) Save summary to CSV
+    summary_df = pd.DataFrame(results_summary)
+    output_dir = os.path.join(os.path.dirname(__file__), "../output")
+    os.makedirs(output_dir, exist_ok=True)
+    summary_path = os.path.join(output_dir, "pair_summary.csv")
+    summary_df.to_csv(summary_path, index=False)
+    logger.info(f"Saved pair summary to {summary_path}.")
+
+    weights_path = os.path.join(output_dir, "portfolio_weights.csv")
+    weights.to_csv(weights_path, header=True)
+    logger.info(f"Saved portfolio weights to {weights_path}.")
+
+    logger.info("Backtest pipeline completed successfully.")
+
+if __name__ == "__main__":
+    main()

Advance_version/signal_generator.py

@@ -0,0 +1,129 @@
+import pandas as pd
+import numpy as np
+import logging
+
+logger = logging.getLogger(__name__)
+
+class SignalGenerator:
+    """
+    Given spread & dynamic betas, computes z-scores, applies adaptive thresholds, 
+    volatility & momentum filters, and outputs daily position signals (signed, float).
+    """
+
+    def __init__(
+        self,
+        price1: pd.Series,
+        price2: pd.Series,
+        kalman_df: pd.DataFrame,
+        config: dict
+    ):
+        """
+        :param price1: Series of prices for ticker1.
+        :param price2: Series of prices for ticker2.
+        :param kalman_df: DataFrame with columns ['alpha', 'beta', 'spread'] indexed by date.
+        :param config: dictionary under key 'signal' from config.yaml.
+        """
+        self.price1 = price1
+        self.price2 = price2
+        self.alpha = kalman_df["alpha"]
+        self.beta = kalman_df["beta"]
+        self.spread = kalman_df["spread"]
+        self.dates = kalman_df.index
+        self.z_window = config["zscore_window"]
+        self.entry_z = config["entry_z"]
+        self.exit_z = config["exit_z"]
+        self.target_vol = config["target_vol"]
+        self.min_vol_pct = config["min_vol_percentile"]
+        self.momentum_filter = config["momentum_filter"]
+
+        # Placeholder for signals & positions
+        self.zscore = None
+        self.entry_thresh = None
+        self.exit_thresh = None
+        self.positions = None  # will store a DataFrame with columns ['pos1', 'pos2']
+
+    def generate(self, costs: dict, volume: pd.DataFrame) -> pd.DataFrame:
+        """
+        1. Compute rolling z-score of spread.
+        2. Compute dynamic entry/exit thresholds (scaled by rolling vol).
+        3. Apply volatility & momentum filters.
+        4. Compute volatility‐normalized position sizing:
+           pos1 = +1 (long) or -1 (short) * (target_vol / spread_vol) 
+           pos2 = -beta * pos1
+        5. Return DataFrame with columns ['pos1', 'pos2'], indexed by date.
+        """
+        n = len(self.spread)
+        df = pd.DataFrame(index=self.dates)
+        # 1) Rolling mean & std of spread
+        rolling_mean = self.spread.rolling(self.z_window).mean()
+        rolling_std = self.spread.rolling(self.z_window).std()
+        self.zscore = (self.spread - rolling_mean) / rolling_std
+        df["zscore"] = self.zscore
+
+        # 2) Dynamic thresholds
+        self.entry_thresh = self.entry_z * rolling_std
+        self.exit_thresh = self.exit_z * rolling_std
+        df["entry_thresh"] = self.entry_thresh
+        df["exit_thresh"] = self.exit_thresh
+
+        # 3) Volatility filter: compute rolling volatility percentile rank
+        vol_rank = rolling_std.rank(pct=True) * 100
+        df["vol_rank"] = vol_rank
+
+        # 4) Momentum filter: Δspread
+        dspread = self.spread.diff()
+        df["dspread"] = dspread
+
+        # 5) Initialize positions
+        pos1 = np.zeros(n)
+        pos2 = np.zeros(n)
+        current_signal = 0  # +1 for long spread (long price1, short price2), -1 for short
+
+        for t in range(1, n):
+            # Check if volatility below threshold
+            if vol_rank.iloc[t] > self.min_vol_pct:
+                # Too volatile or not enough data
+                current_signal = 0
+            else:
+                z = self.zscore.iloc[t]
+                # Check existing position
+                if current_signal == 0:
+                    # Look for entry
+                    if z > self.entry_thresh.iloc[t]:
+                        # Spread is high → short spread (sell price1, buy price2)
+                        # Momentum filter: require Δspread < 0 (i.e., spread rolling down)
+                        if not self.momentum_filter or dspread.iloc[t] < 0:
+                            current_signal = -1
+                    elif z < -self.entry_thresh.iloc[t]:
+                        # Spread is low → long spread (buy price1, sell price2)
+                        if not self.momentum_filter or dspread.iloc[t] > 0:
+                            current_signal = +1
+                elif current_signal == +1:
+                    # Already long spread; check exit when z ≥ -exit_thresh (close)
+                    if z >= -self.exit_thresh.iloc[t]:
+                        current_signal = 0
+                elif current_signal == -1:
+                    # Already short spread; check exit when z ≤ exit_thresh (close)
+                    if z <= self.exit_thresh.iloc[t]:
+                        current_signal = 0
+
+            # 6) Position sizing based on volatility normalization
+            if current_signal != 0 and rolling_std.iloc[t] > 0:
+                # Dollar‐volatility of spread per unit of price1 = rolling_std / price1
+                # But simpler: scale pos1 so that spread vol = target_vol
+                scale = self.target_vol / rolling_std.iloc[t]
+                pos1[t] = current_signal * scale
+                pos2[t] = -current_signal * scale * self.beta.iloc[t]
+            else:
+                pos1[t] = 0.0
+                pos2[t] = 0.0
+
+        df["pos1"] = pos1
+        df["pos2"] = pos2
+
+        # Attach price series for later P&L calculations
+        df["price1"] = self.price1
+        df["price2"] = self.price2
+
+        logger.info("Signals generated.")
+        return df

Advance_version/utils.py

@@ -0,0 +1,98 @@
+import numpy as np
+import pandas as pd
+from sklearn.cluster import AgglomerativeClustering
+from statsmodels.tsa.stattools import coint
+import logging
+
+logger = logging.getLogger(__name__)
+
+def half_life(spread: pd.Series) -> float:
+    """
+    Estimate the half-life of mean reversion for a spread series S_t 
+    by fitting: ΔS_t = a + kappa * S_{t-1} + ε_t. 
+    Returns: hl = -ln(2) / kappa.
+    """
+    spread_lag = spread.shift(1).dropna()
+    spread_ret = (spread - spread_lag).dropna()
+    spread_lag = spread_lag.loc[spread_ret.index]
+
+    # Add constant
+    X = np.vstack([np.ones(len(spread_lag)), spread_lag.values]).T
+    y = spread_ret.values
+
+    # OLS regression
+    beta = np.linalg.lstsq(X, y, rcond=None)[0]
+    kappa = beta[1]
+    if kappa >= 0:
+        return np.inf
+    hl = -np.log(2) / kappa
+    return hl
+
+
+def zscore(series: pd.Series) -> pd.Series:
+    """
+    Compute z-score based on rolling mean/std.
+    Assumes 'series' has no NaN for window-sized segments.
+    """
+    mean = series.rolling(series.name + "_mean").mean()  # placeholder
+    # But we prefer to pass rolling window explicitly, so this may not be used directly.
+
+
+def compute_zscore(spread: pd.Series, window: int) -> pd.Series:
+    """
+    Compute rolling z-score over 'window' periods.
+    """
+    m = spread.rolling(window).mean()
+    s = spread.rolling(window).std()
+    return (spread - m) / s
+
+
+def cluster_universe(returns: pd.DataFrame, cluster_size: int) -> dict:
+    """
+    Perform hierarchical agglomerative clustering on returns to group assets 
+    into clusters of approximate size 'cluster_size'. Returns a dict mapping 
+    cluster_label -> list of tickers.
+    """
+    n_assets = returns.shape[1]
+    # Compute pairwise distance as 1 - correlation
+    corr = returns.corr().fillna(0)
+    dist = 1 - corr.abs()
+    # Convert to condensed form for clustering if needed, but sklearn Agglomerative supports precomputed.
+    n_clusters = max(1, n_assets // cluster_size)
+    model = AgglomerativeClustering(
+        n_clusters=n_clusters, linkage="average", metric="precomputed"
+    )
+    labels = model.fit_predict(dist.values)
+    clusters = {}
+    tickers = returns.columns.tolist()
+    for i, lab in enumerate(labels):
+        clusters.setdefault(lab, []).append(tickers[i])
+    logger.info(f"Formed {n_clusters} clusters.")
+    return clusters
+
+
+def rolling_cointegration_test(
+    series1: pd.Series,
+    series2: pd.Series,
+    window: int,
+    step: int,
+    pval_threshold: float,
+    min_valid_periods: int
+) -> bool:
+    """
+    Run rolling Engle‐Granger cointegration tests over consecutive windows.
+    Return True if at least 'min_valid_periods' consecutive windows have pval < threshold.
+    """
+    n = len(series1)
+    valid = 0
+    for start in range(0, n - window + 1, step):
+        seg1 = series1.iloc[start : start + window]
+        seg2 = series2.iloc[start : start + window]
+        score, pval, _ = coint(seg1, seg2)
+        if pval < pval_threshold:
+            valid += 1
+            if valid >= min_valid_periods:
+                return True
+        else:
+            valid = 0
+    return False

output/pair_summary.csv

@@ -0,0 +1,92 @@
+pair,annual_return,annual_vol,sharpe,max_drawdown,half_life
+005810.KS/3N4.SG,0.0,0.0,,0.0,69.89134265705191
+005810.KS/9CM0.F,0.0,0.0,,0.0,41.83425338360788
+005810.KS/ARREF,0.0,0.0,,0.0,32.13116349951154
+005810.KS/BHAGYANGR.NS,0.0,0.0,,0.0,74.93174990279714
+005810.KS/CUBEXTUB.NS,0.0,0.0,,0.0,78.616169063629
+005810.KS/FDY.TO,0.0,0.0,,0.0,37.934485267520856
+005810.KS/GRX.L,0.0,0.0,,0.0,63.274106994412925
+005810.KS/HINDCOPPER.NS,0.0,0.0,,0.0,85.08157376122398
+005810.KS/JIX.F,0.0,0.0,,0.0,51.60848998374307
+005810.KS/MTJ3.F,0.0,0.0,,0.0,41.559572435658886
+005810.KS/OUW0.F,0.0,0.0,,0.0,69.49905471320476
+2009.TW/9CM0.F,0.0015379683024434598,0.013866530810193085,0.11091226230232884,-0.021404924568302307,36.45085847767775
+2009.TW/ATYM.L,2.2086948121335936e-05,0.0002737536008921058,0.08068185422715606,-0.000924767795943129,33.14600025115992
+2009.TW/CUBEXTUB.NS,0.00016970114358705324,0.0003105846147590616,0.5463926270742683,-0.0006140813909702956,111.29149639797315
+2009.TW/MTJ3.F,-0.0009624965054081391,0.003769537532899947,-0.2553354349194342,-0.012749500002018684,117.8922602920659
+2009.TW/OUW0.F,0.008679668544795627,0.00807960775157276,1.0742685550676716,-0.01643492715817114,39.72993107682057
+2009.TW/RE8.F,0.0014093521632039252,0.007366838829065429,0.1913103022755716,-0.01505594784051718,94.74302958043734
+2009.TW/SFR.AX,0.000104417903831866,0.0009819877561163303,0.10633320342488693,-0.0012578764214811159,120.1390203977421
+3N4.SG/9CM0.F,2.8987950810066963,71.85231668778763,0.040343794252348575,-154.10616875700134,242.65941495753827
+3N4.SG/ARREF,0.2995852352905628,6.0534022666034355,0.049490389387034754,-0.7519215927748252,103.56924279210467
+3N4.SG/RE8.F,1.4069783664689646,29.229876467895537,0.0481349405637862,-58.34256154333586,70.2851958509006
+9CM0.F/ARREF,0.020923271238472596,0.09319695228763693,0.22450595995775047,-0.08714316707490799,18.936737605822337
+9CM0.F/ATYM.L,-0.007306943916109754,0.04824493966184529,-0.15145513637958763,-0.1349914136257513,15.799100864512194
+9CM0.F/BHAGYANGR.NS,0.0660025567021083,0.07181790076192135,0.9190265379784478,-0.11963854656971595,49.013472541787415
+9CM0.F/CUBEXTUB.NS,0.08416347778181765,0.07927215497488543,1.061702912056344,-0.04684297884964142,63.98739503536009
+9CM0.F/FDY.TO,0.04251903531427881,0.08612845163691686,0.49367003012572513,-0.05936287611549328,1.6622221263419488
+9CM0.F/HINDCOPPER.NS,0.00884256658845528,0.04893411161646993,0.18070352758747346,-0.1329083093955279,59.27821905145623
+9CM0.F/JIX.F,0.046107376456388405,0.09382954568836062,0.49139507303516594,-0.07141317069741386,72.83614052376302
+9CM0.F/MTJ3.F,0.033289223403817125,0.09226784423892787,0.360789001611597,-0.07141298265884881,47.8306364618964
+9CM0.F/PUCOBRE.SN,0.051261099430377266,0.05680058376299433,0.9024748696997363,-0.04894630374447549,28.099354514019833
+9CM0.F/RE8.F,0.02900050584965297,0.09399063418967529,0.30854676212875926,-0.07939818590197838,28.675231823192284
+ARREF/ATYM.L,0.0037633568393642403,0.028708754219775777,0.1310874310516715,-0.05008849350184719,20.286772076201153
+ARREF/CUBEXTUB.NS,0.0024948307834449235,0.022787597062696785,0.10948195970732486,-0.06250663175970615,64.37950748503815
+ARREF/FDY.TO,-0.021233110164099234,0.02314828699304472,-0.9172648572431761,-0.12805478466341516,20.53548141479908
+ARREF/OUW0.F,-0.015477774449879966,0.023435157478104332,-0.6604510536931951,-0.09505692175817171,28.231379537957697
+ARREF/RE8.F,-0.0035045189420866985,0.025326914883228396,-0.13837133177272246,-0.06557218853931879,5.999667008278748
+ARREF/SFR.AX,-0.022230191649560083,0.03523261016328443,-0.6309550029513837,-0.1409957452957015,45.14644359217902
+ATYM.L/CS.TO,0.0,0.0,,0.0,33.516715432823155
+ATYM.L/FDY.TO,0.0,0.0,,0.0,17.69026387464004
+ATYM.L/GRX.L,0.0,0.0,,0.0,105.10435295463033
+ATYM.L/JIX.F,0.0,0.0,,0.0,73.59510974256123
+ATYM.L/OUW0.F,0.0,0.0,,0.0,25.977190637745423
+ATYM.L/RE8.F,0.0,0.0,,0.0,29.44341876789875
+ATYM.L/SFR.AX,0.0,0.0,,0.0,62.05631321652151
+BHAGYANGR.NS/CS.TO,-8.876559449988441e-05,0.0010920247313968073,-0.0812853335165262,-0.0024916594820197533,28.962437832974977
+BHAGYANGR.NS/CUBEXTUB.NS,4.2282180329200614e-05,9.822323565167935e-05,0.43047024513774207,-0.00012514096629827033,27.925111599290567
+BHAGYANGR.NS/FDY.TO,9.911246990657041e-05,0.002455826086957325,0.040358098007406945,-0.004730781288453918,62.91333379646588
+BHAGYANGR.NS/GRX.AX,-0.00028971644498221316,0.0027666816044103855,-0.10471622196076855,-0.004754839723490601,58.5688555418701
+BHAGYANGR.NS/GRX.L,-4.830143746636928e-05,0.00016255117534607288,-0.29714603640075254,-0.0004534759599134583,70.16643742811367
+BHAGYANGR.NS/HINDCOPPER.NS,-3.8906339715483185e-06,5.3084088097616206e-05,-0.07329190555922974,-0.00010590328464739472,14.298136259522273
+BHAGYANGR.NS/JIX.F,0.00021248348827240804,0.0008360393411925331,0.2541548917654041,-0.001573780458168519,82.86601697948797
+BHAGYANGR.NS/MTJ3.F,0.0010953382058949135,0.0029114438939769065,0.3762182084844262,-0.003879630758871827,44.02024694727368
+BHAGYANGR.NS/OUW0.F,0.0002688760548834601,0.002906038105831274,0.0925232378556674,-0.00512370528019637,30.059580022493094
+BHAGYANGR.NS/PUCOBRE.SN,1.0853064599913864e-05,9.517074745370657e-05,0.11403782034172913,-0.0001502581670337344,65.54660043248278
+BHAGYANGR.NS/RE8.F,-0.0001648495804892347,0.0028389424813802687,-0.05806724918536789,-0.006427505868697349,46.54475715603291
+BHAGYANGR.NS/SARKY.IS,1.152373992097111e-05,0.0003076963931195794,0.037451657473581965,-0.0011547569680025978,49.75643015271566
+BHAGYANGR.NS/SFR.AX,5.148194635107295e-05,0.00023199920393676454,0.2219057025950195,-0.0003673161103447137,46.41425765070565
+CS.TO/OUW0.F,0.006187800697393442,0.011450643773166767,0.5403888916616045,-0.010711454829312204,1.6029516630222154
+CUBEXTUB.NS/FDY.TO,0.0007845263421744075,0.00149862588500968,0.5234971249474581,-0.001508410754706569,108.85442303098509
+CUBEXTUB.NS/GRX.AX,6.36384739103324e-05,0.0030177910306884094,0.021087766933887194,-0.008873880414873359,88.17099292025958
+CUBEXTUB.NS/GRX.L,0.0,0.0,,0.0,111.26334875320688
+CUBEXTUB.NS/HINDCOPPER.NS,2.1590568998197668e-05,4.805911155933034e-05,0.44925027320872335,0.0,26.31800953856392
+CUBEXTUB.NS/JIX.F,6.993202933047726e-05,0.0006040330998564552,0.11577516090938757,-0.0010356158396423942,24.488841933734584
+CUBEXTUB.NS/MTJ3.F,0.0004744674348713396,0.0008331120468301126,0.5695121522688682,-0.0009682388753128803,71.39234518921627
+CUBEXTUB.NS/OUW0.F,-0.000529896113936057,0.002003546866609874,-0.26447902106361715,-0.004676234619514956,60.82984989421814
+CUBEXTUB.NS/PUCOBRE.SN,1.702947541759592e-05,8.20094476946929e-05,0.20765260462421029,-0.0001521841752243347,121.81500189351588
+CUBEXTUB.NS/RE8.F,0.0013420286969336725,0.0025721291554915045,0.5217578962037878,-0.00374363280468474,50.295751753165455
+CUBEXTUB.NS/SARKY.IS,8.817683939099652e-05,0.00042747308157015535,0.2062746011213463,-0.0008173960233719408,105.67658869939382
+CUBEXTUB.NS/SFR.AX,-2.096582469846009e-05,0.0005353518793677406,-0.039162699350604825,-0.0014792863446207276,29.143035344954246
+FDY.TO/GRX.AX,0.03439703967170815,0.040228115273470505,0.8550497441373345,-0.07067463276570908,83.37890978249656
+FDY.TO/GRX.L,0.03221525812505788,0.02856757983020966,1.1276859403746504,-0.0264660912702098,90.3190850219358
+FDY.TO/HINDCOPPER.NS,0.029843026681218632,0.02606342493930019,1.1450155438404912,-0.028939678849369387,64.9646934714888
+FDY.TO/JIX.F,0.03662617136257906,0.04142029319458316,0.8842566900846791,-0.06823372195345995,68.30254918328009
+FDY.TO/MTJ3.F,0.043489900843854734,0.04060907095061916,1.0709405516008648,-0.06920837368805552,52.65188014940165
+FDY.TO/OUW0.F,0.04134423179278279,0.03929824006617014,1.0520631896789177,-0.05680185812103446,20.34109050555137
+FDY.TO/PUCOBRE.SN,0.031150896643225456,0.028719725752592056,1.084651605366182,-0.02383241147450124,29.69317449514897
+FDY.TO/RE8.F,0.03852685628627506,0.04167859449359142,0.9243799306187982,-0.060438420765762196,24.87211352505537
+GRX.AX/GRX.L,0.036849859888825165,0.0375898423162381,0.9803142981769498,-0.027466995669377794,2.137919235933928
+GRX.AX/HINDCOPPER.NS,0.012865011490230671,0.023730905530123896,0.5421205471447302,-0.05062274662696435,82.1427350570934
+GRX.AX/JIX.F,0.01566849916564017,0.03303988678568906,0.4742298079673459,-0.05384346927344101,96.9863284772213
+GRX.AX/MTJ3.F,0.022513800480160384,0.034772512438693344,0.6474597002403543,-0.048067964931316605,23.8286308823473
+GRX.AX/OUW0.F,0.03296054738584675,0.03480105648583718,0.9471134130442432,-0.0532757434592191,84.7114907644092
+GRX.AX/PUCOBRE.SN,0.022388696356388627,0.03916873670884552,0.5715960798738899,-0.03835050678554284,93.87755243063428
+GRX.AX/RE8.F,0.019196722316995762,0.04069770262865231,0.47169056426002626,-0.05270274959090142,77.00619129671291
+GRX.AX/SARKY.IS,0.039963876009710075,0.03344178625800246,1.19502815134903,-0.030603297577380766,30.766531733933597
+GRX.AX/SFR.AX,0.031333332577252015,0.037561451620305525,0.8341885423915134,-0.038559708139174684,72.3670527555053
+JIX.F/SFR.AX,0.015151394990011946,0.04746400657228732,0.31921862658046973,-0.08521344096114344,37.210056047668964
+MTJ3.F/RE8.F,0.015277409029052613,0.02963431947212822,0.5155309553648221,-0.0856450808450801,51.31666799334718
+MTJ3.F/SFR.AX,-0.010076787153644795,0.024376770054227493,-0.41337663403430464,-0.08978013192865307,79.00933735832268
+PUCOBRE.SN/SARKY.IS,0.0,0.0,,0.0,126.22931397278033
+RE8.F/SFR.AX,-0.013851531714805354,0.05638419622891655,-0.24566337096602286,-0.1474315665002387,44.75423200487218

output/portfolio_metrics.csv

@@ -0,0 +1,2 @@
+annual_return,annual_vol,sharpe,max_drawdown
+0.017780666121420152,0.01101873703285444,1.6136755118489303,-0.008674351588195456

output/portfolio_weights.csv

@@ -0,0 +1,57 @@
+,0
+2009.TW/9CM0.F,0.019356938303344905
+2009.TW/ATYM.L,0.019276209356947783
+2009.TW/CUBEXTUB.NS,0.019276647446920484
+2009.TW/OUW0.F,0.019265760341899654
+2009.TW/RE8.F,0.019302079382489568
+2009.TW/SFR.AX,0.01927866704138942
+3N4.SG/9CM0.F,1.600026089701147e-05
+3N4.SG/ARREF,-1.4033629405966763e-08
+3N4.SG/RE8.F,2.776962026905125e-07
+9CM0.F/ARREF,0.01683404735011321
+9CM0.F/BHAGYANGR.NS,0.017710650821087238
+9CM0.F/CUBEXTUB.NS,0.017252421447959645
+9CM0.F/FDY.TO,0.01696192143711173
+9CM0.F/HINDCOPPER.NS,0.018922788182741408
+9CM0.F/JIX.F,0.016824229933070544
+9CM0.F/MTJ3.F,0.016832237280803984
+9CM0.F/PUCOBRE.SN,0.019035491677081465
+9CM0.F/RE8.F,0.01671660866888466
+ARREF/ATYM.L,0.01919393506512004
+ARREF/CUBEXTUB.NS,0.019268867373268328
+BHAGYANGR.NS/CUBEXTUB.NS,0.0192767066786576
+BHAGYANGR.NS/FDY.TO,0.019278384220307747
+BHAGYANGR.NS/JIX.F,0.01927673216947256
+BHAGYANGR.NS/MTJ3.F,0.019273899481384575
+BHAGYANGR.NS/OUW0.F,0.0192806434608896
+BHAGYANGR.NS/PUCOBRE.SN,0.019276740189728896
+BHAGYANGR.NS/SARKY.IS,0.01927643334278014
+BHAGYANGR.NS/SFR.AX,0.019276583462850962
+CS.TO/OUW0.F,0.019219583853766795
+CUBEXTUB.NS/FDY.TO,0.0192742692579241
+CUBEXTUB.NS/GRX.AX,0.019271860877920412
+CUBEXTUB.NS/HINDCOPPER.NS,0.01927667384870885
+CUBEXTUB.NS/JIX.F,0.0192822843975036
+CUBEXTUB.NS/MTJ3.F,0.019274920210791805
+CUBEXTUB.NS/PUCOBRE.SN,0.019276659462253796
+CUBEXTUB.NS/RE8.F,0.019269532749390687
+CUBEXTUB.NS/SARKY.IS,0.01927701639747627
+FDY.TO/GRX.AX,0.018795273835669365
+FDY.TO/GRX.L,0.019161403617310207
+FDY.TO/HINDCOPPER.NS,0.019201626745230304
+FDY.TO/JIX.F,0.018764988751327354
+FDY.TO/MTJ3.F,0.01880835759194311
+FDY.TO/OUW0.F,0.01885245862626124
+FDY.TO/PUCOBRE.SN,0.01911990767601962
+FDY.TO/RE8.F,0.018782827094670183
+GRX.AX/GRX.L,0.01900340047400452
+GRX.AX/HINDCOPPER.NS,0.01913912361141376
+GRX.AX/JIX.F,0.019020941561484168
+GRX.AX/MTJ3.F,0.018993074243052094
+GRX.AX/OUW0.F,0.018949323808203217
+GRX.AX/PUCOBRE.SN,0.019163099561725568
+GRX.AX/RE8.F,0.018970021501792528
+GRX.AX/SARKY.IS,0.019008665335682448
+GRX.AX/SFR.AX,0.018963413787314264
+JIX.F/SFR.AX,0.019117617799609916
+MTJ3.F/RE8.F,0.019219786903504947

trade_details.csv

@@ -0,0 +1,167 @@
+Date,V_Price,MA_Price,Beta,Spread,Z-Score,Position
+2022-02-01,385.1221618652344,226.6815948486328,1.698997462238565,-0.009292518783354353,-0.8713897237619049,0.0
+2022-02-24,362.8435974121094,212.33453369140625,1.708769658946882,0.012788693599929957,1.6541589842934814,-1.0
+2022-02-25,362.5587463378906,214.25950622558594,1.692183822482254,-0.007723910081722352,-1.0506848483260303,1.0
+2022-03-02,338.0011291503906,203.716064453125,1.6591728826121726,0.000959257292095117,0.3169645002202774,0.0
+2022-03-11,319.0426940917969,192.2150115966797,1.6597907892569284,0.005988286714284641,1.0820874131932998,-1.0
+2022-03-15,329.0719299316406,201.42953491210938,1.6337199966045473,-0.007529161026241127,-1.1657623950867881,1.0
+2022-03-16,338.58062744140625,207.0286102294922,1.6354251976640835,0.0008216347184770711,0.3682846009231695,0.0
+2022-03-18,343.89495849609375,214.1031494140625,1.606266767052406,-0.011815128970681599,-1.7301559150902894,1.0
+2022-03-23,336.1249084472656,209.77435302734375,1.6023300948467785,-0.0028505354596859434,-0.15922090692229954,0.0
+2022-03-24,343.16802978515625,212.34429931640625,1.616062115411025,0.006452236412883394,1.696741088575966,-1.0
+2022-03-25,342.8439025878906,213.4386749267578,1.6063089884619992,-0.004559432379210193,-0.4967617367767362,0.0
+2022-03-29,361.04595947265625,222.90725708007812,1.6196662227320948,0.010604378194102537,2.191600264918986,-1.0
+2022-03-31,351.0559997558594,216.70237731933594,1.620004249029402,-0.002772276237578808,-0.35807215326871655,0.0
+2022-04-12,340.1522521972656,206.56932067871094,1.6466309021390433,0.00882533383048667,1.6556254496612903,-1.0
+2022-04-18,350.97265625,208.29888916015625,1.6849652119108185,-0.003725664530747963,-1.0176329684611791,1.0
+2022-04-21,358.48779296875,211.50393676757812,1.694931778741407,0.0030492124687384603,0.15526813873362297,0.0
+2022-04-26,338.4898986816406,196.50473022460938,1.7224959264975666,0.011301332247739992,1.5466823971462649,-1.0
+2022-04-27,355.66473388671875,209.2174072265625,1.7000279755795624,-0.01071137665923061,-2.16250218073127,1.0
+2022-04-28,372.642822265625,215.6177215576172,1.7281964821250637,0.013034385929472592,1.6609387370301136,-1.0
+2022-04-29,357.44512939453125,208.25982666015625,1.71636941200485,-0.005666834393139197,-1.2256617891172599,1.0
+2022-05-04,362.50115966796875,209.6180419921875,1.7293359352714737,0.0011469696341350755,-0.23861776732149803,0.0
+2022-05-06,341.45074462890625,198.18540954589844,1.7229115509604658,-0.005186709552731372,-1.0801055355571185,1.0
+2022-05-13,327.3645935058594,195.0492401123047,1.6783314417449464,0.0073211369187902164,1.0658109967579399,-1.0
+2022-05-16,324.3447265625,193.65904235839844,1.6748328632364742,-0.0018018422500745146,-0.20071102435017932,0.0
+2022-05-18,330.41400146484375,195.7932891845703,1.687517288181404,0.009441055980232704,1.2907520682269953,-1.0
+2022-05-24,335.125732421875,198.37789916992188,1.6893233234540768,0.0013204963048565332,0.317910262297382,0.0
+2022-06-01,351.2283630371094,205.52468872070312,1.7089016329953104,0.006886861446957937,1.2638101351013376,-1.0
+2022-06-08,356.4122619628906,209.01980590820312,1.7051601331790787,2.188339379927129e-05,-0.05644141721841759,0.0
+2022-06-10,329.2827453613281,195.3233642578125,1.6858742852930837,-0.007891757852178216,-1.73843943442919,1.0
+2022-06-14,316.8786926269531,189.45909118652344,1.6725398748674623,0.0008079613421045906,0.17824890597167806,0.0
+2022-06-16,303.7369079589844,185.0828399658203,1.6411606183339826,-0.013760122330836566,-2.3679495060793565,1.0
+2022-06-17,305.61572265625,186.02272033691406,1.6428896176998418,0.0009267584526924111,0.4203095274464105,0.0
+2022-06-23,311.5865783691406,192.51361083984375,1.6185718579540374,-0.010534409345780205,-1.5873846851052007,1.0
+2022-06-24,325.1021423339844,201.1974639892578,1.6158429067767806,-0.0013527145346188263,0.16171254543539496,0.0
+2022-06-27,323.4594421386719,199.28839111328125,1.623054061376715,0.0036095570295060497,1.007168175757446,-1.0
+2022-06-28,313.0915832519531,193.96253967285156,1.6142092818595024,-0.004548621005824316,-0.4903142951727661,0.0
+2022-06-29,317.3213806152344,195.31358337402344,1.6246491620163739,0.005331056212014573,1.3354470297807317,-1.0
+2022-07-01,313.0423889160156,195.00027465820312,1.60535542505928,-0.002359894580422406,0.008911272349719201,0.0
+2022-07-07,319.26580810546875,198.54432678222656,1.608011357379714,0.004275696339107071,1.3782762472485337,-1.0
+2022-07-12,318.0737609863281,200.52195739746094,1.5862406788498085,-0.0023248401126920726,0.057621582992309704,0.0
+2022-07-13,318.5762023925781,199.86598205566406,1.5939298996672235,0.003837667702384806,1.2084711792217937,-1.0
+2022-07-14,320.2115173339844,201.58908081054688,1.5884502647453211,-0.0027114492947362123,-0.10823739805409809,0.0
+2022-07-18,326.1029357910156,202.86180114746094,1.6074784361704821,0.006964923767782238,1.7704559006923328,-1.0
+2022-07-19,335.33404541015625,209.1764373779297,1.603125693681451,-0.002075863151901558,-0.23520523924680745,0.0
+2022-07-27,338.18115234375,206.0533905029297,1.6411720421429,0.012088661588450123,2.4856951609432287,-1.0
+2022-07-29,348.54522705078125,207.65895080566406,1.67844929981724,0.0002064702317170486,-0.2571156402891086,0.0
+2022-08-01,345.3434143066406,206.92469787597656,1.6689549173571432,-0.0045777361116847715,-1.0769100297524834,1.0
+2022-08-02,343.8360900878906,201.9317169189453,1.7026519992064635,0.016648572654730742,2.17972537849096,-1.0
+2022-08-04,350.7913818359375,208.9904022216797,1.6785749231209075,-0.014666506326022954,-2.1803234503995075,1.0
+2022-08-18,352.0622863769531,211.10630798339844,1.6676928378548015,0.0018085270696701627,0.06095102554861629,0.0
+2022-09-07,323.7483825683594,196.56179809570312,1.6470353605213508,0.0041505770780077,1.0781302732716491,-1.0
+2022-09-12,333.4030456542969,202.65225219726562,1.6451951737454968,0.0005383907002283195,0.4765621898360632,0.0
+2022-09-13,320.61553955078125,195.82623291015625,1.63726572380837,-0.00403941553219056,-1.104522737490833,1.0
+2022-09-16,310.4582824707031,189.57884216308594,1.637599055977204,0.004149511182220067,1.5005166920930897,-1.0
+2022-09-19,309.3746032714844,189.4121551513672,1.633352615231713,-0.0022357016762271087,-0.3983450009368775,0.0
+2022-09-20,308.6258850097656,188.37254333496094,1.6383663209773272,0.0026542129235735956,1.0212210358208584,-1.0
+2022-09-21,299.98590087890625,183.41976928710938,1.635524062072271,-0.001545249905689161,-0.33290163361032404,0.0
+2022-09-22,293.9368591308594,182.21340942382812,1.6132131453322827,-0.012208207473406674,-2.755845144457649,1.0
+2022-09-26,285.8091735839844,177.11354064941406,1.6136724175616397,0.005938261342635087,1.5108100982330033,-1.0
+2022-09-29,282.5187072753906,176.59373474121094,1.5999087885006382,-0.015160931223249463,-2.4970290313955736,1.0
+2022-10-04,296.80377197265625,182.07614135742188,1.630036730404185,0.012973829794077574,2.043838964797215,-1.0
+2022-10-05,299.6903381347656,184.0572509765625,1.6282504716636348,-0.000967580934286616,-0.07556540812973683,0.0
+2022-10-17,291.1351318359375,181.68382263183594,1.6023916298638752,0.0064951690106909155,1.1358144865770117,-1.0
+2022-10-19,293.819091796875,182.82151794433594,1.6071586389486536,-0.004090153070819724,-0.49237682474029887,0.0
+2022-10-20,292.3586730957031,183.61590576171875,1.5922735800095655,-0.008082518207800149,-1.174378848232363,1.0
+2022-10-24,301.5553283691406,187.0387420654297,1.612220933572808,0.007553022129968667,1.1893081737032174,-1.0
+2022-10-26,315.2812194824219,199.41578674316406,1.5811015977965515,-0.015399563051175846,-1.9972352273197413,1.0
+2022-11-01,328.7801208496094,202.94647216796875,1.6199704842305895,0.012826058775203819,2.031531122672483,-1.0
+2022-11-02,315.58709716796875,197.0816192626953,1.6013493493574906,-0.009425608669062058,-1.2732445913651174,1.0
+2022-11-04,314.1563415527344,193.18801879882812,1.626091852298869,0.014878222199229185,1.9365682898407368,-1.0
+2022-11-14,334.87835693359375,203.33128356933594,1.646994282269107,-0.0071045115409447135,-1.0494715613821142,1.0
+2022-11-22,340.3944091796875,206.74209594726562,1.6464672317442657,0.0003227803857157596,-0.07213585495381308,0.0
+2022-11-28,340.0293273925781,207.65623474121094,1.63749055698827,-0.005796095894311293,-1.0766660222795783,1.0
+2022-11-30,351.6830139160156,213.2982940673828,1.6487824712515218,0.0005255098623706544,-0.03690346798938799,0.0
+2022-12-01,356.02471923828125,213.2982940673828,1.6690954719175388,0.00950244267698963,1.3262464600366217,-1.0
+2022-12-14,352.7782897949219,209.6811065673828,1.6824526167287452,-0.00023662795024392835,-0.27325445147569744,0.0
+2022-12-15,341.66729736328125,204.36337280273438,1.6718869482903826,-0.005158334212126192,-1.3129400999762781,1.0
+2022-12-16,341.26275634765625,203.3607635498047,1.678100054589528,0.0030479333609036985,0.41239471703467173,0.0
+2022-12-28,337.42425537109375,201.49322509765625,1.6746426643049293,-0.004895945838143234,-1.384479218994223,1.0
+2022-12-29,343.6014099121094,204.5108184814453,1.680100594342152,0.0026622320331171068,0.47822859085398794,0.0
+2023-01-06,363.3927001953125,214.0355224609375,1.6977604985121424,0.011644882724397121,2.87224874024429,-1.0
+2023-01-10,366.69378662109375,217.3185577392578,1.687396162117543,-0.008713665049583597,-2.066274564239814,1.0
+2023-01-11,373.4640808105469,218.31134033203125,1.7106461477298303,0.010627465821698934,2.0080584976337903,-1.0
+2023-01-12,375.3913879394531,219.80538940429688,1.7078410246225804,-0.0012735183465224509,-0.37773082695781596,0.0
+2023-01-13,371.1513366699219,219.25491333007812,1.6928157721823813,-0.006838743715434248,-1.375623858467934,1.0
+2023-01-30,366.8024597167969,225.19190979003906,1.6288365843502401,0.0016385510822374272,0.33066667686555223,0.0
+2023-03-03,357.29443359375,220.38363647460938,1.6212542394102907,-0.003471337366818261,-1.0381443760644253,1.0
+2023-03-13,340.6997375488281,211.22439575195312,1.6129724024016827,0.0006164869565168374,0.2967598574750179,0.0
+2023-03-14,348.71539306640625,215.35098266601562,1.6192750485478886,0.0029201550582911295,1.1482527927038366,-1.0
+2023-03-16,343.95147705078125,214.15928649902344,1.6060726904056573,-0.003904392061258477,-1.302002989229021,1.0
+2023-03-17,345.5921936035156,214.10018920898438,1.614143515776242,0.0037614653669493237,1.655574248623593,-1.0
+2023-03-20,345.256103515625,214.84869384765625,1.6069887149743203,-0.0033229245312895728,-1.279277256731132,1.0
+2023-03-27,350.4944152832031,218.45330810546875,1.6044196322685884,0.0036390247703366185,1.6399152074292744,-1.0
+2023-04-03,362.20660400390625,225.53451538085938,1.6060146175336325,-0.0051244561177554715,-1.7091647144032622,1.0
+2023-04-13,365.9227600097656,229.1686553955078,1.5967390426060775,0.0002205982203804524,0.2223392030038708,0.0
+2023-04-19,369.04095458984375,229.0504913330078,1.6111599095760176,0.003985685412487783,1.4712008690482106,-1.0
+2023-04-26,363.06195068359375,224.69735717773438,1.6157773367298176,0.0010533327255188851,0.4148465888237753,0.0
+2023-04-27,369.90228271484375,225.54434204101562,1.6399948816015522,0.010716193388361717,2.975960523583482,-1.0
+2023-05-01,376.0298156738281,228.99134826660156,1.6421120771809472,0.0003571152933545818,-0.05235487257484481,0.0
+2023-05-02,372.23846435546875,223.54507446289062,1.665114719543511,0.010270385859371345,2.4033766836987365,-1.0
+2023-05-03,371.1198425292969,222.56019592285156,1.6674984135943536,0.0010688986933473643,-0.08899787209200058,0.0
+2023-05-05,380.78143310546875,228.27244567871094,1.66811531425513,-0.0033293536612291064,-1.210602735868505,1.0
+2023-05-11,379.5242614746094,227.9576416015625,1.664884900495458,0.0010260196127092058,-0.11509805195247924,0.0
+2023-05-12,378.069091796875,228.32275390625,1.6558710230451887,-0.003940298362067551,-1.1778282557153885,1.0
+2023-05-16,376.40594482421875,227.4247589111328,1.6550732923711053,0.0013003264652979851,0.025913580838604223,0.0
+2023-05-17,383.09783935546875,229.57595825195312,1.6686935379247532,0.005921357551642359,1.02986622965584,-1.0
+2023-05-19,381.6822204589844,230.22726440429688,1.6578979247478065,-0.011083417263932915,-2.2487593342202077,1.0
+2023-05-23,369.98138427734375,221.6125946044922,1.6694929031247197,0.0007303420885023115,-0.0976187082728893,0.0
+2023-06-01,367.1403503417969,223.50723266601562,1.642661022539504,-0.006269014335202883,-1.2073102150204904,1.0
+2023-06-05,366.7839660644531,223.77366638183594,1.6390838068728015,0.00017309342922544602,0.17929006526321933,0.0
+2023-06-06,376.1288146972656,225.2045135498047,1.6701044829003096,0.01374704835330931,2.4432659214975327,-1.0
+2023-06-07,367.6452331542969,222.29347229003906,1.653905992109082,-0.007272672932913338,-1.3185583497282485,1.0
+2023-06-09,365.4971008300781,220.60609436035156,1.6567788084127906,0.0015986871352424714,0.33061114091715815,0.0
+2023-06-14,370.9812316894531,220.48765563964844,1.6825182723057237,0.006722257892477046,1.0964661382332492,-1.0
+2023-06-15,375.2181091308594,223.18157958984375,1.6812260565223036,-0.0005778113923042838,-0.15637522854656752,0.0
+2023-06-16,372.7333984375,225.88539123535156,1.650160383308101,-0.013725347128115573,-2.137878384874019,1.0
+2023-06-22,373.9906005859375,225.3722686767578,1.6594368173799132,-0.00043967271221845294,-0.038568404934278856,0.0
+2023-07-20,394.6161804199219,236.45384216308594,1.6688724706641183,0.00487265118920277,1.4201448371701,-1.0
+2023-07-21,394.05108642578125,236.0887908935547,1.6690796599521671,8.760264870488754e-05,-0.03913377317079649,0.0
+2023-07-24,401.28790283203125,237.55906677246094,1.6891776147109354,0.008445068369837827,2.0714113109040126,-1.0
+2023-07-25,397.80828857421875,235.53616333007812,1.6889482284457165,-9.72170176396503e-05,-0.11982246554262932,0.0
+2023-07-26,398.92852783203125,233.96719360351562,1.705032485355222,0.006862230642639133,1.7418320012391706,-1.0
+2023-07-27,391.0869445800781,231.3423309326172,1.6905388504410124,-0.006253613092781052,-1.7375221496842947,1.0
+2023-08-03,389.6098327636719,235.605224609375,1.653647662160239,0.0018038956409327511,0.4315900088013289,0.0
+2023-08-22,394.3980407714844,237.83773803710938,1.6582445140834419,0.00491642943302395,1.46646916785896,-1.0
+2023-08-31,409.07000732421875,242.88967895507812,1.684182652458312,-0.0005764330925330796,-0.47807769746031864,0.0
+2023-09-01,411.9746398925781,245.29209899902344,1.679534454379057,-0.0018917632403372409,-1.085954588762225,1.0
+2023-09-05,407.93988037109375,242.5535430908203,1.6818510324600322,0.0009534969586866282,0.12923903277053178,0.0
+2023-09-11,413.0849609375,244.4121856689453,1.6901027493718126,0.0032539584415758327,1.1298533341289927,-1.0
+2023-09-13,412.6983642578125,245.01527404785156,1.6843839073192315,-0.0014203957999825434,-1.0061732992676327,1.0
+2023-09-14,409.7639465332031,238.75717163085938,1.7161815407049197,0.013295869405965277,3.386738267373946,-1.0
+2023-09-18,413.52117919921875,241.8812713623047,1.7096273232062695,-0.0056512936475314746,-1.833987988138692,1.0
+2023-09-25,399.0077819824219,230.70960998535156,1.729454682422577,0.005966713369105037,1.1837976706056528,-1.0
+2023-10-02,392.42529296875,228.64332580566406,1.716339212543432,-0.0042127978548478495,-1.2478352524411938,1.0
+2023-10-06,395.0988464355469,232.37051391601562,1.7002879081926865,0.0020714036251092693,0.3943303582986671,0.0
+2023-10-13,395.1584167480469,234.9706573486328,1.6817609081397857,-0.006049340792287694,-1.5182760086126854,1.0
+2023-10-23,380.9020080566406,228.90037536621094,1.6640324936901674,0.004345629389263195,1.8972652094319884,-1.0
+2023-10-25,383.5229797363281,234.1599884033203,1.6378998624536432,-0.00763306161690025,-1.723754886591619,1.0
+2023-10-27,361.45330810546875,226.6660614013672,1.594628831493994,0.005071473660677839,1.2850045983754101,-1.0
+2023-11-15,393.967041015625,245.81430053710938,1.6027198962464777,-0.004429237111423845,-0.47187932041490727,0.0
+2023-11-27,406.01953125,251.7884979248047,1.6125622773163302,-0.00510236568112532,-1.590237528780358,1.0
+2023-12-01,411.3705749511719,254.07713317871094,1.619072085312121,0.0013811053908625581,0.2115065096454037,0.0
+2023-12-04,405.2848815917969,252.08572387695312,1.6077442310925305,-0.0044867121590641545,-1.7378501039327083,1.0
+2023-12-06,407.41937255859375,251.93711853027344,1.6171334277860407,0.003436483194604989,1.043888094830782,-1.0
+2023-12-12,417.71453857421875,257.15838623046875,1.6243466509968976,0.0001751249901644769,-0.0027225700360828118,0.0
+2023-12-18,421.36798095703125,255.9793701171875,1.6460699926537061,0.008021068732091408,2.3335483519063738,-1.0
+2023-12-26,420.6134338378906,256.7620544433594,1.6381543343295613,-0.002438539861316258,-1.0308447599350001,1.0
+2023-12-27,421.2984619140625,256.5341491699219,1.6422642506145397,0.001599670482221427,0.4182501857200979,0.0
+2024-01-02,418.8462829589844,256.4747619628906,1.633102542756725,-0.0033029555380608144,-1.245399642333756,1.0
+2024-01-10,425.8503723144531,262.1120910644531,1.6246676688156183,0.005332356381018144,1.8416081181238526,-1.0
+2024-01-11,424.3091735839844,261.58697509765625,1.6220615275688748,-0.0009948350411264073,-0.3279064354243026,0.0
+2024-01-16,425.929931640625,262.7857971191406,1.6208391166185407,-0.0035676218619755673,-1.1547012483304182,1.0
+2024-01-19,434.31231689453125,268.3934020996094,1.6181846229135608,0.0022407254871836813,1.0144634894294242,-1.0
+2024-01-23,436.2811584472656,268.7500915527344,1.6233767360605325,-0.0014879935815770295,-0.4578111742474664,0.0
+2024-01-25,434.3321838378906,270.08758544921875,1.608133430952922,-0.00469160835200455,-1.5106158463332637,1.0
+2024-01-26,436.05242919921875,265.4608154296875,1.642575653689146,0.012956765946057658,3.194444263549746,-1.0
+2024-01-29,438.0908203125,271.12786865234375,1.6158452007281603,-0.009845033044655338,-2.0309471388606246,1.0
+2024-01-31,446.6919860839844,270.7315979003906,1.6498926279697408,0.013918549661752877,2.4385096159755455,-1.0
+2024-02-02,457.9778747558594,274.6153259277344,1.6677095319732367,-0.0007219197603944849,-0.28095128645096684,0.0
+2024-02-20,449.19775390625,273.1124267578125,1.644787520734429,-0.014157382495739057,-2.2463600283303236,1.0
+2024-02-26,471.82916259765625,282.0457458496094,1.6728809135279743,0.0002176240828362097,-0.0568458765807258,0.0
+2024-03-04,465.8431396484375,278.45257568359375,1.6729882515608747,-0.004748087080145069,-1.1575693258045445,1.0
+2024-03-05,464.87860107421875,277.3111267089844,1.6763747886975895,0.0012196339545766932,0.2388647559444203,0.0
+2024-03-22,478.94873046875,281.162353515625,1.7034373876277566,0.0062654968219248985,2.4665706015814823,-1.0
+2024-03-25,473.35052490234375,279.1275329589844,1.695831440726785,-0.0027214620038762405,-1.2862579964546386,1.0
+2024-03-27,475.24969482421875,276.9537048339844,1.7159717490915911,0.00496152285035123,1.6403750929502,-1.0