diff --git a/lib/pt_trading/sliding_fit.py b/lib/pt_trading/sliding_fit.py
index 9488af3..9898ca5 100644
--- a/lib/pt_trading/sliding_fit.py
+++ b/lib/pt_trading/sliding_fit.py
@@ -5,14 +5,10 @@ from typing import Dict, Optional, cast
import pandas as pd # type: ignore[import]
from pt_trading.fit_method import PairState, PairsTradingFitMethod
from pt_trading.results import BacktestResult
-from pt_trading.trading_pair import TradingPair
+from pt_trading.trading_pair import CointegrationData, TradingPair
NanoPerMin = 1e9
-
-
-
-
class SlidingFit(PairsTradingFitMethod):
def __init__(self) -> None:
super().__init__()
@@ -37,7 +33,6 @@ class SlidingFit(PairsTradingFitMethod):
"scaled_disequilibrium": "float64",
"pair": "object"
})
- pair.user_data_["is_cointegrated"] = False
training_minutes = config["training_minutes"]
curr_predicted_row_idx = 0
@@ -59,31 +54,10 @@ class SlidingFit(PairsTradingFitMethod):
try:
# ================================ TRAINING ================================
- is_cointegrated = pair.train_pair()
+ pair.train_pair()
except Exception as e:
raise RuntimeError(f"{pair}: Training failed: {str(e)}") from e
- if pair.user_data_["is_cointegrated"] != is_cointegrated:
- pair.user_data_["is_cointegrated"] = is_cointegrated
- if not is_cointegrated:
- if pair.user_data_["state"] == PairState.OPEN:
- print(
- f"{pair} {curr_training_start_idx} LOST COINTEGRATION. Consider closing positions..."
- )
- else:
- print(
- f"{pair} {curr_training_start_idx} IS NOT COINTEGRATED. Moving on"
- )
- else:
- print("*" * 80)
- print(
- f"Pair {pair} ({curr_training_start_idx}) IS COINTEGRATED"
- )
- print("*" * 80)
- if not is_cointegrated:
- curr_training_start_idx += 1
- continue
-
try:
# ================================ PREDICTION ================================
pair.predict()
diff --git a/lib/pt_trading/static_fit.py b/lib/pt_trading/static_fit.py
index e182930..12bf3a7 100644
--- a/lib/pt_trading/static_fit.py
+++ b/lib/pt_trading/static_fit.py
@@ -18,14 +18,6 @@ class StaticFit(PairsTradingFitMethod):
) -> Optional[pd.DataFrame]: # abstractmethod
config = pair.config_
pair.get_datasets(training_minutes=config["training_minutes"])
- try:
- is_cointegrated = pair.train_pair()
- if not is_cointegrated:
- print(f"{pair} IS NOT COINTEGRATED")
- return None
- except Exception as e:
- print(f"{pair}: Training failed: {str(e)}")
- return None
try:
pair.predict()
diff --git a/lib/pt_trading/trading_pair.py b/lib/pt_trading/trading_pair.py
index e3e0645..7c3ba0c 100644
--- a/lib/pt_trading/trading_pair.py
+++ b/lib/pt_trading/trading_pair.py
@@ -1,8 +1,63 @@
+from __future__ import annotations
+
from typing import Any, Dict, List, Optional
import pandas as pd # type:ignore
from statsmodels.tsa.vector_ar.vecm import VECM, VECMResults # type:ignore
+class CointegrationData:
+ EG_PVALUE_THRESHOLD = 0.05
+
+ tstamp_: pd.Timestamp
+ pair_: str
+ eg_pvalue_: float
+ johansen_lr1_: float
+ johansen_cvt_: float
+ eg_is_cointegrated_: bool
+ johansen_is_cointegrated_: bool
+
+ def __init__(self, pair: TradingPair):
+ training_df = pair.training_df_
+
+ assert training_df is not None
+ from statsmodels.tsa.vector_ar.vecm import coint_johansen
+
+ df = training_df[pair.colnames()].reset_index(drop=True)
+
+ # Run Johansen cointegration test
+ result = coint_johansen(df, det_order=0, k_ar_diff=1)
+ self.johansen_lr1_ = result.lr1[0]
+ self.johansen_cvt_ = result.cvt[0, 1]
+ self.johansen_is_cointegrated_ = self.johansen_lr1_ > self.johansen_cvt_
+
+ # Run Engle-Granger cointegration test
+ from statsmodels.tsa.stattools import coint #type: ignore
+
+ col1, col2 = pair.colnames()
+ assert training_df is not None
+ series1 = training_df[col1].reset_index(drop=True)
+ series2 = training_df[col2].reset_index(drop=True)
+
+ self.eg_pvalue_ = float(coint(series1, series2)[1])
+ self.eg_is_cointegrated_ = bool(self.eg_pvalue_ < self.EG_PVALUE_THRESHOLD)
+
+ self.tstamp_ = training_df.index[-1]
+ self.pair_ = pair.name()
+
+ def to_dict(self) -> Dict[str, Any]:
+ return {
+ "tstamp": self.tstamp_,
+ "pair": self.pair_,
+ "eg_pvalue": self.eg_pvalue_,
+ "johansen_lr1": self.johansen_lr1_,
+ "johansen_cvt": self.johansen_cvt_,
+ "eg_is_cointegrated": self.eg_is_cointegrated_,
+ "johansen_is_cointegrated": self.johansen_is_cointegrated_,
+ }
+
+ def __repr__(self) -> str:
+ return f"CointegrationData(tstamp={self.tstamp_}, pair={self.pair_}, eg_pvalue={self.eg_pvalue_}, johansen_lr1={self.johansen_lr1_}, johansen_cvt={self.johansen_cvt_}, eg_is_cointegrated={self.eg_is_cointegrated_}, johansen_is_cointegrated={self.johansen_is_cointegrated_})"
+
class TradingPair:
market_data_: pd.DataFrame
@@ -148,42 +203,7 @@ class TradingPair:
# print(f"{self}: {self.vecm_fit_.summary()}")
pass
- def check_cointegration_johansen(self) -> bool:
- assert self.training_df_ is not None
- from statsmodels.tsa.vector_ar.vecm import coint_johansen
-
- df = self.training_df_[self.colnames()].reset_index(drop=True)
- result = coint_johansen(df, det_order=0, k_ar_diff=1)
- # print(
- # f"{self}: lr1={result.lr1[0]} > cvt={result.cvt[0, 1]}? {result.lr1[0] > result.cvt[0, 1]}"
- # )
- is_cointegrated: bool = bool(result.lr1[0] > result.cvt[0, 1])
-
- return is_cointegrated
-
- def check_cointegration_engle_granger(self) -> bool:
- from statsmodels.tsa.stattools import coint
-
- col1, col2 = self.colnames()
- assert self.training_df_ is not None
- series1 = self.training_df_[col1].reset_index(drop=True)
- series2 = self.training_df_[col2].reset_index(drop=True)
-
- # Run Engle-Granger cointegration test
- pvalue = coint(series1, series2)[1]
- # Define cointegration if p-value < 0.05 (i.e., reject null of no cointegration)
- is_cointegrated: bool = bool(pvalue < 0.05)
- # print(f"{self}: is_cointegrated={is_cointegrated} pvalue={pvalue}")
- return is_cointegrated
-
- def check_cointegration(self) -> bool:
- is_cointegrated_johansen = self.check_cointegration_johansen()
- is_cointegrated_engle_granger = self.check_cointegration_engle_granger()
- result = is_cointegrated_johansen or is_cointegrated_engle_granger
- return result or True # TODO: remove this
-
- def train_pair(self) -> bool:
- result = self.check_cointegration()
+ def train_pair(self) -> None:
# print('*' * 80 + '\n' + f"**************** {self} IS COINTEGRATED ****************\n" + '*' * 80)
self.fit_VECM()
assert self.training_df_ is not None and self.vecm_fit_ is not None
@@ -200,8 +220,6 @@ class TradingPair:
diseq_series - self.training_mu_
) / self.training_std_
- return result
-
def add_trades(self, trades: pd.DataFrame) -> None:
if self.user_data_["trades"] is None or len(self.user_data_["trades"]) == 0:
# If trades is empty or None, just assign the new trades directly
@@ -286,6 +304,45 @@ class TradingPair:
self.predicted_df_ = self.predicted_df_.reset_index(drop=True)
return self.predicted_df_
+ def cointegration_check(self) -> Optional[pd.DataFrame]:
+ print(f"***{self}*** STARTING....")
+ config = self.config_
+
+ curr_training_start_idx = 0
+
+ COINTEGRATION_DATA_COLUMNS = {
+ "tstamp" : "datetime64[ns]",
+ "pair" : "string",
+ "eg_pvalue" : "float64",
+ "johansen_lr1" : "float64",
+ "johansen_cvt" : "float64",
+ "eg_is_cointegrated" : "bool",
+ "johansen_is_cointegrated" : "bool",
+ }
+ # Initialize trades DataFrame with proper dtypes to avoid concatenation warnings
+ result: pd.DataFrame = pd.DataFrame(columns=[col for col in COINTEGRATION_DATA_COLUMNS.keys()]) #.astype(COINTEGRATION_DATA_COLUMNS)
+
+ training_minutes = config["training_minutes"]
+ while True:
+ print(curr_training_start_idx, end="\r")
+ self.get_datasets(
+ training_minutes=training_minutes,
+ training_start_index=curr_training_start_idx,
+ testing_size=1,
+ )
+
+ if len(self.training_df_) < training_minutes:
+ print(
+ f"{self}: current offset={curr_training_start_idx}"
+ f" * Training data length={len(self.training_df_)} < {training_minutes}"
+ " * Not enough training data. Completing the job."
+ )
+ break
+ new_row = pd.Series(CointegrationData(self).to_dict())
+ result.loc[len(result)] = new_row
+ curr_training_start_idx += 1
+ return result
+
def __repr__(self) -> str:
return self.name()
diff --git a/research/cointegration_test.py b/research/cointegration_test.py
new file mode 100644
index 0000000..98c0f14
--- /dev/null
+++ b/research/cointegration_test.py
@@ -0,0 +1,126 @@
+import argparse
+import glob
+import importlib
+import os
+from datetime import date, datetime
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from tools.config import expand_filename, load_config
+from tools.data_loader import get_available_instruments_from_db, load_market_data
+from pt_trading.results import (
+ BacktestResult,
+ create_result_database,
+ store_config_in_database,
+ store_results_in_database,
+)
+from pt_trading.fit_method import PairsTradingFitMethod
+from pt_trading.trading_pair import TradingPair
+
+from research.research_tools import create_pairs, resolve_datafiles
+
+
+def main() -> None:
+ parser = argparse.ArgumentParser(description="Run pairs trading backtest.")
+ parser.add_argument(
+ "--config", type=str, required=True, help="Path to the configuration file."
+ )
+ parser.add_argument(
+ "--datafile",
+ type=str,
+ required=False,
+ help="Market data file to process.",
+ )
+ parser.add_argument(
+ "--instruments",
+ type=str,
+ required=False,
+ help="Comma-separated list of instrument symbols (e.g., COIN,GBTC). If not provided, auto-detects from database.",
+ )
+ args = parser.parse_args()
+
+ config: Dict = load_config(args.config)
+
+ # Resolve data files (CLI takes priority over config)
+ datafile = resolve_datafiles(config, args.datafile)[0]
+
+ if not datafile:
+ print("No data files found to process.")
+ return
+
+ print(f"Found {datafile} data files to process:")
+
+ # # Create result database if needed
+ # if args.result_db.upper() != "NONE":
+ # args.result_db = expand_filename(args.result_db)
+ # create_result_database(args.result_db)
+
+ # # Initialize a dictionary to store all trade results
+ # all_results: Dict[str, Dict[str, Any]] = {}
+
+ # # Store configuration in database for reference
+ # if args.result_db.upper() != "NONE":
+ # # Get list of all instruments for storage
+ # all_instruments = []
+ # for datafile in datafiles:
+ # if args.instruments:
+ # file_instruments = [
+ # inst.strip() for inst in args.instruments.split(",")
+ # ]
+ # else:
+ # file_instruments = get_available_instruments_from_db(datafile, config)
+ # all_instruments.extend(file_instruments)
+
+ # # Remove duplicates while preserving order
+ # unique_instruments = list(dict.fromkeys(all_instruments))
+
+ # store_config_in_database(
+ # db_path=args.result_db,
+ # config_file_path=args.config,
+ # config=config,
+ # fit_method_class=fit_method_class_name,
+ # datafiles=datafiles,
+ # instruments=unique_instruments,
+ # )
+
+ # Process each data file
+ price_column = config["price_column"]
+
+ print(f"\n====== Processing {os.path.basename(datafile)} ======")
+
+ # Determine instruments to use
+ if args.instruments:
+ # Use CLI-specified instruments
+ instruments = [inst.strip() for inst in args.instruments.split(",")]
+ print(f"Using CLI-specified instruments: {instruments}")
+ else:
+ # Auto-detect instruments from database
+ instruments = get_available_instruments_from_db(datafile, config)
+ print(f"Auto-detected instruments: {instruments}")
+
+ if not instruments:
+ print(f"No instruments found in {datafile}...")
+ return
+ # Process data for this file
+ try:
+ cointegration_data: pd.DataFrame = pd.DataFrame()
+ for pair in create_pairs(datafile, price_column, config, instruments):
+ cointegration_data = pd.concat([cointegration_data, pair.cointegration_check()])
+
+ pd.set_option('display.width', 400)
+ pd.set_option('display.max_colwidth', None)
+ pd.set_option('display.max_columns', None)
+ with pd.option_context('display.max_rows', None, 'display.max_columns', None):
+ print(f"cointegration_data:\n{cointegration_data}")
+
+ except Exception as err:
+ print(f"Error processing {datafile}: {str(err)}")
+ import traceback
+
+ traceback.print_exc()
+
+
+
+if __name__ == "__main__":
+ main()
diff --git a/research/notebooks/__DEPRECATED__/pt_pair_backtest.ipynb b/research/notebooks/__DEPRECATED__/pt_pair_backtest.ipynb
deleted file mode 100644
index d849d05..0000000
--- a/research/notebooks/__DEPRECATED__/pt_pair_backtest.ipynb
+++ /dev/null
@@ -1,4433 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "vscode": {
- "languageId": "raw"
- }
- },
- "source": [
- "# Pairs Trading Backtest Notebook\n",
- "\n",
- "This comprehensive notebook supports both StaticFit and SlidingFit.\n",
- "It automatically adapts its analysis and visualization based on the strategy specified in the configuration file.\n",
- "\n",
- "## Key Features:\n",
- "\n",
- "1. **Configuration-Driven**: Loads strategy and parameters from HJSON configuration files\n",
- "2. **Dual Model Support**: Works with both StaticFit and SlidingFit\n",
- "3. **Adaptive Visualization**: Different visualizations based on selected strategy\n",
- "4. **Comprehensive Analysis**: Deep analysis of trading pairs and dis-equilibrium\n",
- "5. **Interactive Configuration**: Easy parameter adjustment and re-running\n",
- "\n",
- "## Usage:\n",
- "\n",
- "1. **Configure Parameters**: Set CONFIG_FILE, SYMBOL_A, SYMBOL_B, and TRADING_DATE\n",
- "2. **Run Analysis**: Execute cells step by step\n",
- "3. **View Results**: Comprehensive visualizations and trading signals\n",
- "4. **Experiment**: Modify parameters and re-run for different scenarios\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "vscode": {
- "languageId": "raw"
- }
- },
- "source": [
- "\n",
- "# Settings"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Trading Parameters Configuration\n",
- "# Specify your configuration file, trading symbols and date here\n",
- "\n",
- "# Configuration file selection\n",
- "CONFIG_FILE = \"equity\" # Options: \"equity\", \"crypto\", or custom filename (without .cfg extension)\n",
- "\n",
- "# Trading pair symbols\n",
- "SYMBOL_A = \"COIN\" # Change this to your desired symbol A\n",
- "SYMBOL_B = \"MSTR\" # Change this to your desired symbol B\n",
- "\n",
- "# Date for data file selection (format: YYYYMMDD)\n",
- "TRADING_DATE = \"20250605\" # Change this to your desired date\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Setup and Configuration"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Code Setup"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Setup complete!\n"
- ]
- }
- ],
- "source": [
- "import sys\n",
- "import os\n",
- "sys.path.append('/home/oleg/develop/pairs_trading/lib')\n",
- "sys.path.append('/home/coder/pairs_trading/lib')\n",
- "\n",
- "import pandas as pd\n",
- "import numpy as np\n",
- "import matplotlib.pyplot as plt\n",
- "import seaborn as sns\n",
- "import importlib\n",
- "from typing import Dict, List, Optional\n",
- "from IPython.display import clear_output\n",
- "\n",
- "# Import our modules\n",
- "from pt_trading.fit_methods import StaticFit, SlidingFit, PairState\n",
- "from tools.data_loader import load_market_data\n",
- "from pt_trading.trading_pair import TradingPair\n",
- "from pt_trading.results import BacktestResult\n",
- "\n",
- "# Set plotting style\n",
- "plt.style.use('seaborn-v0_8')\n",
- "sns.set_palette(\"husl\")\n",
- "plt.rcParams['figure.figsize'] = (15, 10)\n",
- "\n",
- "print(\"Setup complete!\")\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "vscode": {
- "languageId": "raw"
- }
- },
- "source": [
- "## Load Configuration\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {},
- "outputs": [],
- "source": [
- "# Load Configuration from Configuration Files using HJSON\n",
- "import hjson\n",
- "import os\n",
- "\n",
- "def load_config_from_file(config_type) -> Optional[Dict]:\n",
- " \"\"\"Load configuration from configuration files using HJSON\"\"\"\n",
- " config_file = f\"../../configuration/{config_type}.cfg\"\n",
- " \n",
- " try:\n",
- " with open(config_file, 'r') as f:\n",
- " # HJSON handles comments, trailing commas, and other human-friendly features\n",
- " config = hjson.load(f)\n",
- " \n",
- " # Convert relative paths to absolute paths from notebook perspective\n",
- " if 'data_directory' in config:\n",
- " data_dir = config['data_directory']\n",
- " if data_dir.startswith('./'):\n",
- " # Convert relative path to absolute path from notebook's perspective\n",
- " config['data_directory'] = os.path.abspath(f\"../../{data_dir[2:]}\")\n",
- " \n",
- " return config\n",
- " \n",
- " except FileNotFoundError:\n",
- " print(f\"Configuration file not found: {config_file}\")\n",
- " return None\n",
- " except hjson.HjsonDecodeError as e:\n",
- " print(f\"HJSON parsing error in {config_file}: {e}\")\n",
- " return None\n",
- " except Exception as e:\n",
- " print(f\"Unexpected error loading config from {config_file}: {e}\")\n",
- " return None\n",
- "\n",
- "def instantiate_fit_method_from_config(config: Dict):\n",
- " \"\"\"Dynamically instantiate strategy from config\"\"\"\n",
- " fit_method_class_name = config.get(\"fit_method_class\", None)\n",
- " assert fit_method_class_name is not None\n",
- " try:\n",
- " # Split module and class name\n",
- " if '.' in fit_method_class_name:\n",
- " module_name, class_name = fit_method_class_name.rsplit('.', 1)\n",
- " else:\n",
- " module_name = \"fit_methods\"\n",
- " class_name = fit_method_class_name\n",
- " \n",
- " # Import module and get class\n",
- " module = importlib.import_module(module_name)\n",
- " fit_method_class = getattr(module, class_name)\n",
- " \n",
- " # Instantiate strategy\n",
- " return fit_method_class()\n",
- " \n",
- " except Exception as e:\n",
- " print(f\"Error instantiating strategy {fit_method_class_name}: {e}\")\n",
- " raise Exception(f\"Error instantiating strategy {fit_method_class_name}: {e}\") from e\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Print Configuration"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Trading Parameters:\n",
- " Configuration: equity\n",
- " Symbol A: COIN\n",
- " Symbol B: MSTR\n",
- " Trading Date: 20250605\n",
- "\n",
- "Loading equity configuration using HJSON...\n",
- "✓ Successfully loaded EQUITY configuration\n",
- " Data directory: /home/oleg/develop/pairs_trading/data/equity\n",
- " Database table: md_1min_bars\n",
- " Exchange: ALPACA\n",
- " Training window: 120 minutes\n",
- " Open threshold: 2\n",
- " Close threshold: 1\n",
- " Strategy: SlidingFit\n",
- "\n",
- "Data Configuration:\n",
- " Data File: 20250605.mktdata.ohlcv.db\n",
- " Security Type: EQUITY\n",
- " ✓ Data file found: /home/oleg/develop/pairs_trading/data/equity/20250605.mktdata.ohlcv.db\n"
- ]
- }
- ],
- "source": [
- "print(f\"Trading Parameters:\")\n",
- "print(f\" Configuration: {CONFIG_FILE}\")\n",
- "print(f\" Symbol A: {SYMBOL_A}\")\n",
- "print(f\" Symbol B: {SYMBOL_B}\")\n",
- "print(f\" Trading Date: {TRADING_DATE}\")\n",
- "\n",
- "# Load the specified configuration\n",
- "print(f\"\\nLoading {CONFIG_FILE} configuration using HJSON...\")\n",
- "\n",
- "CONFIG = load_config_from_file(CONFIG_FILE)\n",
- "assert CONFIG is not None\n",
- "pt_bt_config: Dict = dict(CONFIG)\n",
- "\n",
- "if pt_bt_config:\n",
- " print(f\"✓ Successfully loaded {pt_bt_config['security_type']} configuration\")\n",
- " print(f\" Data directory: {pt_bt_config['data_directory']}\")\n",
- " print(f\" Database table: {pt_bt_config['db_table_name']}\")\n",
- " print(f\" Exchange: {pt_bt_config['exchange_id']}\")\n",
- " print(f\" Training window: {pt_bt_config['training_minutes']} minutes\")\n",
- " print(f\" Open threshold: {pt_bt_config['dis-equilibrium_open_trshld']}\")\n",
- " print(f\" Close threshold: {pt_bt_config['dis-equilibrium_close_trshld']}\")\n",
- " \n",
- " # Instantiate strategy from config\n",
- " FIT_MODEL = instantiate_fit_method_from_config(pt_bt_config)\n",
- " print(f\" Strategy: {type(FIT_MODEL).__name__}\")\n",
- " \n",
- " # Automatically construct data file name based on date and config type\n",
- " DATA_FILE = f\"{TRADING_DATE}.mktdata.ohlcv.db\"\n",
- "\n",
- " # Update CONFIG with the specific data file and instruments\n",
- " pt_bt_config[\"datafiles\"] = [DATA_FILE]\n",
- " pt_bt_config[\"instruments\"] = [SYMBOL_A, SYMBOL_B]\n",
- " \n",
- " print(f\"\\nData Configuration:\")\n",
- " print(f\" Data File: {DATA_FILE}\")\n",
- " print(f\" Security Type: {pt_bt_config['security_type']}\")\n",
- " \n",
- " # Verify data file exists\n",
- " data_file_path = f\"{pt_bt_config['data_directory']}/{DATA_FILE}\"\n",
- " if os.path.exists(data_file_path):\n",
- " print(f\" ✓ Data file found: {data_file_path}\")\n",
- " else:\n",
- " print(f\" ⚠ Data file not found: {data_file_path}\")\n",
- " print(f\" Please check if the date and file exist in the data directory\")\n",
- " \n",
- " # List available files in the data directory\n",
- " try:\n",
- " data_dir = pt_bt_config['data_directory']\n",
- " if os.path.exists(data_dir):\n",
- " available_files = [f for f in os.listdir(data_dir) if f.endswith('.db')]\n",
- " print(f\" Available files in {data_dir}:\")\n",
- " for file in sorted(available_files)[:5]: # Show first 5 files\n",
- " print(f\" - {file}\")\n",
- " if len(available_files) > 5:\n",
- " print(f\" ... and {len(available_files)-5} more files\")\n",
- " except Exception as e:\n",
- " print(f\" Could not list files in data directory: {e}\")\n",
- "else:\n",
- " print(\"⚠ Failed to load configuration. Please check the configuration file.\")\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "vscode": {
- "languageId": "raw"
- }
- },
- "source": [
- "## Load and Prepare Market Data\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Loading data from: /home/oleg/develop/pairs_trading/data/equity/20250605.mktdata.ohlcv.db\n",
- "Loaded 782 rows of market data\n",
- "Symbols in data: ['COIN' 'MSTR']\n",
- "Time range: 2025-06-05 13:30:00 to 2025-06-05 20:00:00\n",
- "\n",
- "Created trading pair: COIN & MSTR\n",
- "Market data shape: (391, 3)\n",
- "Column names: ['close_COIN', 'close_MSTR']\n",
- "\n",
- "Sample data:\n"
- ]
- },
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " tstamp | \n",
- " close_COIN | \n",
- " close_MSTR | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " | 0 | \n",
- " 2025-06-05 13:30:00 | \n",
- " 263.380 | \n",
- " 384.7700 | \n",
- "
\n",
- " \n",
- " | 1 | \n",
- " 2025-06-05 13:31:00 | \n",
- " 265.385 | \n",
- " 382.7806 | \n",
- "
\n",
- " \n",
- " | 2 | \n",
- " 2025-06-05 13:32:00 | \n",
- " 263.735 | \n",
- " 379.8300 | \n",
- "
\n",
- " \n",
- " | 3 | \n",
- " 2025-06-05 13:33:00 | \n",
- " 264.250 | \n",
- " 380.0400 | \n",
- "
\n",
- " \n",
- " | 4 | \n",
- " 2025-06-05 13:34:00 | \n",
- " 262.230 | \n",
- " 379.6400 | \n",
- "
\n",
- " \n",
- "
\n",
- "