diff --git a/configuration/new_zscore.cfg b/configuration/new_zscore.cfg new file mode 100644 index 0000000..d97e9e1 --- /dev/null +++ b/configuration/new_zscore.cfg @@ -0,0 +1,43 @@ +{ + "market_data_loading": { + "CRYPTO": { + "data_directory": "./data/crypto", + "db_table_name": "md_1min_bars", + "instrument_id_pfx": "PAIR-", + }, + "EQUITY": { + "data_directory": "./data/equity", + "db_table_name": "md_1min_bars", + "instrument_id_pfx": "STOCK-", + } + }, + + # ====== Funding ====== + "funding_per_pair": 2000.0, + # ====== Trading Parameters ====== + "stat_model_price": "close", + "execution_price": { + "column": "vwap", + "shift": 1, + }, + "dis-equilibrium_open_trshld": 2.0, + "dis-equilibrium_close_trshld": 0.5, + "training_size": 120, + "model_class": "pt_strategy.models.ZScoreOLSModel", + "model_data_policy_class": "pt_strategy.model_data_policy.RollingWindowDataPolicy", + + # ====== Stop Conditions ====== + "stop_close_conditions": { + "profit": 2.0, + "loss": -0.5 + } + + # ====== End of Session Closeout ====== + # "close_outstanding_positions": true, + "close_outstanding_positions": false, + "trading_hours": { + "timezone": "America/New_York", + "begin_session": "7:30:00", + "end_session": "18:30:00", + } +} \ No newline at end of file diff --git a/configuration/vecm.cfg b/configuration/vecm.cfg index 536fa4f..973578d 100644 --- a/configuration/vecm.cfg +++ b/configuration/vecm.cfg @@ -23,7 +23,8 @@ }, "dis-equilibrium_open_trshld": 2.0, "dis-equilibrium_close_trshld": 1.0, - "training_minutes": 120, + "training_minutes": 120, # TODO Remove this + "training_size": 120, "fit_method_class": "pt_trading.vecm_rolling_fit.VECMRollingFit", # ====== Stop Conditions ====== @@ -37,7 +38,7 @@ # "close_outstanding_positions": false, "trading_hours": { "timezone": "America/New_York", - "begin_session": "9:30:00", + "begin_session": "7:30:00", "end_session": "18:30:00", } } \ No newline at end of file diff --git a/configuration/zscore.cfg b/configuration/zscore.cfg index 92b5187..5e77c96 100644 --- a/configuration/zscore.cfg +++ b/configuration/zscore.cfg @@ -16,13 +16,14 @@ "funding_per_pair": 2000.0, # ====== Trading Parameters ====== "stat_model_price": "close", - "execution_price": { - "column": "vwap", - "shift": 1, - }, + # "execution_price": { + # "column": "vwap", + # "shift": 1, + # }, "dis-equilibrium_open_trshld": 2.0, "dis-equilibrium_close_trshld": 0.5, - "training_minutes": 120, + "training_minutes": 120, # TODO Remove this + "training_size": 120, "fit_method_class": "pt_trading.z-score_rolling_fit.ZScoreRollingFit", # ====== Stop Conditions ====== @@ -36,7 +37,7 @@ # "close_outstanding_positions": false, "trading_hours": { "timezone": "America/New_York", - "begin_session": "9:30:00", + "begin_session": "7:30:00", "end_session": "18:30:00", } } \ No newline at end of file diff --git a/configuration/zscore_expanding.cfg b/configuration/zscore_expanding.cfg new file mode 100644 index 0000000..4a184a3 --- /dev/null +++ b/configuration/zscore_expanding.cfg @@ -0,0 +1,43 @@ +{ + "market_data_loading": { + "CRYPTO": { + "data_directory": "./data/crypto", + "db_table_name": "md_1min_bars", + "instrument_id_pfx": "PAIR-", + }, + "EQUITY": { + "data_directory": "./data/equity", + "db_table_name": "md_1min_bars", + "instrument_id_pfx": "STOCK-", + } + }, + + # ====== Funding ====== + "funding_per_pair": 2000.0, + # ====== Trading Parameters ====== + "stat_model_price": "close", + "execution_price": { + "column": "vwap", + "shift": 1, + }, + "dis-equilibrium_open_trshld": 2.0, + "dis-equilibrium_close_trshld": 0.5, + "training_minutes": 120, # TODO Remove this + "training_size": 120, + "fit_method_class": "pt_trading.z-score_rolling_fit.ZScoreRollingFit", + + # ====== Stop Conditions ====== + "stop_close_conditions": { + "profit": 2.0, + "loss": -0.5 + } + + # ====== End of Session Closeout ====== + "close_outstanding_positions": true, + # "close_outstanding_positions": false, + "trading_hours": { + "timezone": "America/New_York", + "begin_session": "9:30:00", + "end_session": "18:30:00", + } +} \ No newline at end of file diff --git a/lib/pt_strategy/model_data_policy.py b/lib/pt_strategy/model_data_policy.py new file mode 100644 index 0000000..fc2e110 --- /dev/null +++ b/lib/pt_strategy/model_data_policy.py @@ -0,0 +1,60 @@ +from __future__ import annotations + +from abc import ABC, abstractmethod +from dataclasses import dataclass +from enum import Enum +from typing import Any, Dict, Optional, cast, Generator, List + + +@dataclass +class DataParams: + training_size: int + training_start_index: int + +class ModelDataPolicy(ABC): + config_: Dict[str, Any] + current_data_params_: DataParams + + def __init__(self, config: Dict[str, Any]): + self.config_ = config + self.current_data_params_ = DataParams( + training_size=config.get("training_size", 120), + training_start_index=0, + ) + + @abstractmethod + def advance(self) -> DataParams: + ... + + @staticmethod + def create(config: Dict[str, Any]) -> ModelDataPolicy: + import importlib + + model_data_policy_class_name = config.get("model_data_policy_class", None) + assert model_data_policy_class_name is not None + module_name, class_name = model_data_policy_class_name.rsplit(".", 1) + module = importlib.import_module(module_name) + model_training_data_policy_object = getattr(module, class_name)(config=config) + return cast(ModelDataPolicy, model_training_data_policy_object) + +class RollingWindowDataPolicy(ModelDataPolicy): + def __init__(self, config: Dict[str, Any]): + super().__init__(config) + self.count_ = 1 + + def advance(self) -> DataParams: + self.current_data_params_.training_start_index += 1 + print(self.count_, end='\r') + self.count_ += 1 + return self.current_data_params_ + + +class ExpandingWindowDataPolicy(ModelDataPolicy): + def __init__(self, config: Dict[str, Any]): + super().__init__(config) + + def advance(self) -> DataParams: + self.current_data_params_.training_size += 1 + return self.current_data_params_ + + diff --git a/lib/pt_strategy/models.py b/lib/pt_strategy/models.py new file mode 100644 index 0000000..ca90392 --- /dev/null +++ b/lib/pt_strategy/models.py @@ -0,0 +1,53 @@ +from __future__ import annotations +from typing import Optional + +import pandas as pd +import statsmodels.api as sm + + + +from pt_strategy.pt_model import PairsTradingModel, Prediction +from pt_strategy.trading_pair import TradingPair + + +class ZScoreOLSModel(PairsTradingModel): + zscore_model_: Optional[sm.regression.linear_model.RegressionResultsWrapper] + pair_predict_result_: Optional[pd.DataFrame] + zscore_df_: Optional[pd.DataFrame] + + def _fit_zscore(self, pair: TradingPair) -> pd.DataFrame: + assert self.training_df_ is not None + symbol_a_px_series = self.training_df_[pair.colnames()].iloc[:, 0].astype(float) + symbol_b_px_series = self.training_df_[pair.colnames()].iloc[:, 1].astype(float) + + symbol_a_px_series, symbol_b_px_series = symbol_a_px_series.align( + symbol_b_px_series, axis=0 + ) + + X = sm.add_constant(symbol_b_px_series) + self.zscore_model_ = sm.OLS(symbol_a_px_series, X).fit() + assert self.zscore_model_ is not None + hedge_ratio = self.zscore_model_.params.iloc[1] + + spread = symbol_a_px_series - hedge_ratio * symbol_b_px_series + return pd.DataFrame((spread - spread.mean()) / spread.std()) + + def predict(self, pair: TradingPair) -> Prediction: + self.training_df_ = pair.market_data_.copy() + + zscore_df = self._fit_zscore(pair=pair) + + assert zscore_df is not None + # zscore is both disequilibrium and scaled_disequilibrium + self.training_df_["dis-equilibrium"] = zscore_df[0] + self.training_df_["scaled_dis-equilibrium"] = zscore_df[0] + + assert zscore_df is not None + return Prediction( + tstamp_=pair.market_data_.index[-1], + disequilibrium_=self.training_df_["dis-equilibrium"].iloc[-1], + scaled_disequilibrium_=self.training_df_["scaled_dis-equilibrium"].iloc[-1], + pair_=pair, + ) + + \ No newline at end of file diff --git a/lib/pt_strategy/pt_market_data.py b/lib/pt_strategy/pt_market_data.py new file mode 100644 index 0000000..6446811 --- /dev/null +++ b/lib/pt_strategy/pt_market_data.py @@ -0,0 +1,185 @@ +from __future__ import annotations + +from abc import ABC, abstractmethod +from typing import Any, Dict, List, Type + +import pandas as pd + +from tools.data_loader import load_market_data + + +class PtMarketData(ABC): + config_: Dict[str, Any] + origin_mkt_data_df_: pd.DataFrame + market_data_df_: pd.DataFrame + + def __init__(self, config: Dict[str, Any]): + self.config_ = config + self.origin_mkt_data_df_ = pd.DataFrame() + + @abstractmethod + def load(self) -> None: + ... + + + @abstractmethod + def has_next(self) -> bool: + ... + + @abstractmethod + def get_next(self) -> pd.Series: + ... + + + @staticmethod + def create(config: Dict[str, Any], md_class: Type[PtMarketData]) -> PtMarketData: + return md_class(config) + +class ResearchMarketData(PtMarketData): + config_: Dict[str, Any] + current_index_: int + + is_execution_price_: bool + + def __init__(self, config: Dict[str, Any]): + super().__init__(config) + self.current_index_ = 0 + self.is_execution_price_ = "execution_price" in self.config_ + if self.is_execution_price_: + self.execution_price_column_ = self.config_["execution_price"]["column"] + self.execution_price_shift_ = self.config_["execution_price"]["shift"] + else: + self.execution_price_column_ = None + self.execution_price_shift_ = 0 + + def has_next(self) -> bool: + return self.current_index_ < len(self.market_data_df_) + + def get_next(self) -> pd.Series: + result = self.market_data_df_.iloc[self.current_index_] + self.current_index_ += 1 + return result + + def load(self) -> None: + datafiles: List[str] = self.config_.get("datafiles", []) + instruments: List[Dict[str, str]] = self.config_.get("instruments", []) + assert len(instruments) > 0, "No instruments found in config" + assert len(datafiles) > 0, "No datafiles found in config" + self.symbol_a_ = instruments[0]["symbol"] + self.symbol_b_ = instruments[1]["symbol"] + self.stat_model_price_ = self.config_["stat_model_price"] + + extra_minutes: int + extra_minutes = self.execution_price_shift_ + + for datafile in datafiles: + md_df = load_market_data( + datafile=datafile, + instruments=instruments, + db_table_name=self.config_["market_data_loading"][instruments[0]["instrument_type"]]["db_table_name"], + trading_hours=self.config_["trading_hours"], + extra_minutes=extra_minutes, + ) + self.origin_mkt_data_df_ = pd.concat([self.origin_mkt_data_df_, md_df]) + + self._set_market_data() + + def _set_market_data(self, ) -> None: + if self.is_execution_price_: + self.market_data_df_ = pd.DataFrame( + self._transform_dataframe(self.origin_mkt_data_df_)[["tstamp"] + self.colnames() + self.orig_exec_prices_colnames()] + ) + else: + self.market_data_df_ = pd.DataFrame( + self._transform_dataframe(self.origin_mkt_data_df_)[["tstamp"] + self.colnames()] + ) + + self.market_data_df_ = self.market_data_df_.dropna().reset_index(drop=True) + self.market_data_df_["tstamp"] = pd.to_datetime(self.market_data_df_["tstamp"]) + self.market_data_df_ = self.market_data_df_.sort_values("tstamp") + self._set_execution_price_data() + + def _transform_dataframe(self, df: pd.DataFrame) -> pd.DataFrame: + df_selected: pd.DataFrame + if self.is_execution_price_: + execution_price_column = self.config_["execution_price"]["column"] + + df_selected = pd.DataFrame( + df[["tstamp", "symbol", self.stat_model_price_, execution_price_column]] + ) + else: + df_selected = pd.DataFrame( + df[["tstamp", "symbol", self.stat_model_price_]] + ) + + result_df = pd.DataFrame(df_selected["tstamp"]).drop_duplicates().reset_index(drop=True) + + # For each unique symbol, add a corresponding stat_model_price column + symbols = df_selected["symbol"].unique() + + + + for symbol in symbols: + # Filter rows for this symbol + df_symbol = df_selected[df_selected["symbol"] == symbol].reset_index( + drop=True + ) + + # Create column name like "close-COIN" + new_price_column = f"{self.stat_model_price_}_{symbol}" + if self.is_execution_price_: + new_execution_price_column = f"{self.execution_price_column_}_{symbol}" + + # Create temporary dataframe with timestamp and price + temp_df = pd.DataFrame( + { + "tstamp": df_symbol["tstamp"], + new_price_column: df_symbol[self.stat_model_price_], + new_execution_price_column: df_symbol[execution_price_column], + } + ) + else: + temp_df = pd.DataFrame( + { + "tstamp": df_symbol["tstamp"], + new_price_column: df_symbol[self.stat_model_price_], + } + ) + + # Join with our result dataframe + result_df = pd.merge(result_df, temp_df, on="tstamp", how="left") + result_df = result_df.reset_index( + drop=True + ) # do not dropna() since irrelevant symbol would affect dataset + + return result_df.dropna() + + def _set_execution_price_data(self) -> None: + if "execution_price" not in self.config_: + self.market_data_df_[f"exec_price_{self.symbol_a_}"] = self.market_data_df_[f"{self.stat_model_price_}_{self.symbol_a_}"] + self.market_data_df_[f"exec_price_{self.symbol_b_}"] = self.market_data_df_[f"{self.stat_model_price_}_{self.symbol_b_}"] + return + execution_price_column = self.config_["execution_price"]["column"] + execution_price_shift = self.config_["execution_price"]["shift"] + self.market_data_df_[f"exec_price_{self.symbol_a_}"] = self.market_data_df_[f"{execution_price_column}_{self.symbol_a_}"].shift(-execution_price_shift) + self.market_data_df_[f"exec_price_{self.symbol_b_}"] = self.market_data_df_[f"{execution_price_column}_{self.symbol_b_}"].shift(-execution_price_shift) + self.market_data_df_ = self.market_data_df_.dropna().reset_index(drop=True) + + def colnames(self) -> List[str]: + return [ + f"{self.stat_model_price_}_{self.symbol_a_}", + f"{self.stat_model_price_}_{self.symbol_b_}", + ] + + def orig_exec_prices_colnames(self) -> List[str]: + return [ + f"{self.execution_price_column_}_{self.symbol_a_}", + f"{self.execution_price_column_}_{self.symbol_b_}", + ] + + def exec_prices_colnames(self) -> List[str]: + return [ + f"exec_price_{self.symbol_a_}", + f"exec_price_{self.symbol_b_}", + ] + diff --git a/lib/pt_strategy/pt_model.py b/lib/pt_strategy/pt_model.py new file mode 100644 index 0000000..c23ea30 --- /dev/null +++ b/lib/pt_strategy/pt_model.py @@ -0,0 +1,48 @@ +from __future__ import annotations + +from abc import ABC, abstractmethod +from dataclasses import dataclass +from enum import Enum +from typing import Any, Dict, Optional, cast, Generator, List + +import pandas as pd + +from pt_strategy.trading_pair import TradingPair + +@dataclass +class Prediction: + tstamp_: pd.Timestamp + disequilibrium_: float + scaled_disequilibrium_: float + pair_: TradingPair + + def to_dict(self) -> Dict[str, Any]: + return { + "tstamp": self.tstamp_, + "disequilibrium": self.disequilibrium_, + "signed_scaled_disequilibrium": self.scaled_disequilibrium_, + "scaled_disequilibrium": abs(self.scaled_disequilibrium_), + "pair": self.pair_, + } + def to_pd_series(self) -> pd.Series: + return pd.DataFrame([self.to_dict()]).iloc[0] + +class PairsTradingModel(ABC): + + @abstractmethod + def predict(self, pair: TradingPair) -> Prediction: + ... + + @staticmethod + def create(config: Dict[str, Any]) -> PairsTradingModel: + import importlib + + model_class_name = config.get("model_class", None) + assert model_class_name is not None + module_name, class_name = model_class_name.rsplit(".", 1) + module = importlib.import_module(module_name) + model_object = getattr(module, class_name)() + return cast(PairsTradingModel, model_object) + + + diff --git a/lib/pt_strategy/results.py b/lib/pt_strategy/results.py new file mode 100644 index 0000000..474f574 --- /dev/null +++ b/lib/pt_strategy/results.py @@ -0,0 +1,580 @@ +import os +import sqlite3 +from datetime import date, datetime +from typing import Any, Dict, List, Optional, Tuple + +import pandas as pd +from pt_trading.trading_pair import TradingPair + + +# Recommended replacement adapters and converters for Python 3.12+ +# From: https://docs.python.org/3/library/sqlite3.html#sqlite3-adapter-converter-recipes +def adapt_date_iso(val: date) -> str: + """Adapt datetime.date to ISO 8601 date.""" + return val.isoformat() + + +def adapt_datetime_iso(val: datetime) -> str: + """Adapt datetime.datetime to timezone-naive ISO 8601 date.""" + return val.isoformat() + + +def convert_date(val: bytes) -> date: + """Convert ISO 8601 date to datetime.date object.""" + return datetime.fromisoformat(val.decode()).date() + + +def convert_datetime(val: bytes) -> datetime: + """Convert ISO 8601 datetime to datetime.datetime object.""" + return datetime.fromisoformat(val.decode()) + + +# Register the adapters and converters +sqlite3.register_adapter(date, adapt_date_iso) +sqlite3.register_adapter(datetime, adapt_datetime_iso) +sqlite3.register_converter("date", convert_date) +sqlite3.register_converter("datetime", convert_datetime) + + +def create_result_database(db_path: str) -> None: + """ + Create the SQLite database and required tables if they don't exist. + """ + try: + # Create directory if it doesn't exist + db_dir = os.path.dirname(db_path) + if db_dir and not os.path.exists(db_dir): + os.makedirs(db_dir, exist_ok=True) + print(f"Created directory: {db_dir}") + + conn = sqlite3.connect(db_path) + cursor = conn.cursor() + + # Create the pt_bt_results table for completed trades + cursor.execute( + """ + CREATE TABLE IF NOT EXISTS pt_bt_results ( + date DATE, + pair TEXT, + symbol TEXT, + open_time DATETIME, + open_side TEXT, + open_price REAL, + open_quantity INTEGER, + open_disequilibrium REAL, + close_time DATETIME, + close_side TEXT, + close_price REAL, + close_quantity INTEGER, + close_disequilibrium REAL, + symbol_return REAL, + pair_return REAL, + close_condition TEXT + ) + """ + ) + cursor.execute("DELETE FROM pt_bt_results;") + + # Create the outstanding_positions table for open positions + cursor.execute( + """ + CREATE TABLE IF NOT EXISTS outstanding_positions ( + date DATE, + pair TEXT, + symbol TEXT, + position_quantity REAL, + last_price REAL, + unrealized_return REAL, + open_price REAL, + open_side TEXT + ) + """ + ) + cursor.execute("DELETE FROM outstanding_positions;") + + # Create the config table for storing configuration JSON for reference + cursor.execute( + """ + CREATE TABLE IF NOT EXISTS config ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + run_timestamp DATETIME, + config_file_path TEXT, + config_json TEXT, + datafiles TEXT, + instruments TEXT + ) + """ + ) + cursor.execute("DELETE FROM config;") + + conn.commit() + conn.close() + + except Exception as e: + print(f"Error creating result database: {str(e)}") + raise + + +def store_config_in_database( + db_path: str, + config_file_path: str, + config: Dict, + datafiles: List[Tuple[str, str]], + instruments: List[Dict[str, str]], +) -> None: + """ + Store configuration information in the database for reference. + """ + import json + + if db_path.upper() == "NONE": + return + + try: + conn = sqlite3.connect(db_path) + cursor = conn.cursor() + + # Convert config to JSON string + config_json = json.dumps(config, indent=2, default=str) + + # Convert lists to comma-separated strings for storage + datafiles_str = ", ".join([f"{datafile}" for _, datafile in datafiles]) + instruments_str = ", ".join( + [ + f"{inst['symbol']}:{inst['instrument_type']}:{inst['exchange_id']}" + for inst in instruments + ] + ) + + # Insert configuration record + cursor.execute( + """ + INSERT INTO config ( + run_timestamp, config_file_path, config_json, datafiles, instruments + ) VALUES (?, ?, ?, ?, ?) + """, + ( + datetime.now(), + config_file_path, + config_json, + datafiles_str, + instruments_str, + ), + ) + + conn.commit() + conn.close() + + print(f"Configuration stored in database") + + except Exception as e: + print(f"Error storing configuration in database: {str(e)}") + import traceback + + traceback.print_exc() + + +def convert_timestamp(timestamp: Any) -> Optional[datetime]: + """Convert pandas Timestamp to Python datetime object for SQLite compatibility.""" + if timestamp is None: + return None + if isinstance(timestamp, pd.Timestamp): + return timestamp.to_pydatetime() + elif isinstance(timestamp, datetime): + return timestamp + elif isinstance(timestamp, date): + return datetime.combine(timestamp, datetime.min.time()) + elif isinstance(timestamp, str): + return datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S") + elif isinstance(timestamp, int): + return datetime.fromtimestamp(timestamp) + else: + raise ValueError(f"Unsupported timestamp type: {type(timestamp)}") + + + +DayT = str +TradeT = Dict[str, Any] +OutstandingPositionT = List[Dict[str, Any]] +class PairResearchResult: + """ + Class to handle pair research results for a single pair across multiple days. + Simplified version of BacktestResult focused on single pair analysis. + """ + trades_: Dict[DayT, pd.DataFrame] + outstanding_positions_: Dict[DayT, OutstandingPositionT] + + def __init__(self, config: Dict[str, Any]) -> None: + self.config_ = config + self.trades_ = {} + self.outstanding_positions_ = {} + self.total_realized_pnl = 0.0 + self.symbol_roundtrip_trades_: Dict[str, List[Dict[str, Any]]] = {} + + def add_day_results(self, day: DayT, trades: pd.DataFrame, outstanding_positions: List[Dict[str, Any]]) -> None: + assert isinstance(trades, pd.DataFrame) + self.trades_[day] = trades + self.outstanding_positions_[day] = outstanding_positions + + @property + def all_trades(self) -> List[TradeT]: + """Get all trades across all days as a flat list.""" + all_trades_list = [] + for day_trades in self.trades_.values(): + all_trades_list.extend(day_trades) + return all_trades_list + + @property + def outstanding_positions(self) -> List[OutstandingPositionT]: + """Get all outstanding positions across all days as a flat list.""" + all_positions = [] + for day_positions in self.outstanding_positions_.values(): + all_positions.extend(day_positions) + return all_positions + + + def calculate_returns(self) -> None: + """Calculate and store total returns for the single pair across all days.""" + roundtrip_trades = self.extract_roundtrip_trades() + + self.total_realized_pnl = 0.0 + + for day, day_trades in roundtrip_trades.items(): + for trade in day_trades: + self.total_realized_pnl += trade['symbol_return'] + + def extract_roundtrip_trades(self) -> Dict[str, List[Dict[str, Any]]]: + """ + Extract round-trip trades by day, grouping open/close pairs for each symbol. + Returns a dictionary with day as key and list of completed round-trip trades. + """ + roundtrip_trades_by_day = {} + + def _symbol_return(trade1_side: str, trade1_px: float, trade2_side: str, trade2_px: float) -> float: + if trade1_side == "BUY" and trade2_side == "SELL": + return (trade2_px - trade1_px) / trade1_px * 100 + elif trade1_side == "SELL" and trade2_side == "BUY": + return (trade1_px - trade2_px) / trade1_px * 100 + else: + return 0 + + # Process each day separately + for day, day_trades in self.trades_.items(): + if not day_trades or len(day_trades) < 4: + continue + + # Sort trades by timestamp for the day + sorted_trades = sorted(day_trades, key=lambda x: x["timestamp"] if x["timestamp"] else pd.Timestamp.min) + + day_roundtrips = [] + + # Process trades in groups of 4 (open A, open B, close A, close B) + for idx in range(0, len(sorted_trades), 4): + if idx + 3 >= len(sorted_trades): + break + + trade_a_1 = sorted_trades[idx] # Open A + trade_b_1 = sorted_trades[idx + 1] # Open B + trade_a_2 = sorted_trades[idx + 2] # Close A + trade_b_2 = sorted_trades[idx + 3] # Close B + + # Validate trade sequence + if not (trade_a_1["action"] == "OPEN" and trade_a_2["action"] == "CLOSE"): + continue + if not (trade_b_1["action"] == "OPEN" and trade_b_2["action"] == "CLOSE"): + continue + + # Calculate individual symbol returns + symbol_a_return = _symbol_return( + trade_a_1["side"], trade_a_1["price"], + trade_a_2["side"], trade_a_2["price"] + ) + symbol_b_return = _symbol_return( + trade_b_1["side"], trade_b_1["price"], + trade_b_2["side"], trade_b_2["price"] + ) + + pair_return = symbol_a_return + symbol_b_return + + # Create round-trip records for both symbols + funding_per_position = self.config_.get("funding_per_pair", 10000) / 2 + + # Symbol A round-trip + day_roundtrips.append({ + "symbol": trade_a_1["symbol"], + "open_side": trade_a_1["side"], + "open_price": trade_a_1["price"], + "open_time": trade_a_1["timestamp"], + "close_side": trade_a_2["side"], + "close_price": trade_a_2["price"], + "close_time": trade_a_2["timestamp"], + "symbol_return": symbol_a_return, + "pair_return": pair_return, + "shares": funding_per_position / trade_a_1["price"], + "close_condition": trade_a_2.get("status", "UNKNOWN"), + "open_disequilibrium": trade_a_1.get("disequilibrium"), + "close_disequilibrium": trade_a_2.get("disequilibrium"), + }) + + # Symbol B round-trip + day_roundtrips.append({ + "symbol": trade_b_1["symbol"], + "open_side": trade_b_1["side"], + "open_price": trade_b_1["price"], + "open_time": trade_b_1["timestamp"], + "close_side": trade_b_2["side"], + "close_price": trade_b_2["price"], + "close_time": trade_b_2["timestamp"], + "symbol_return": symbol_b_return, + "pair_return": pair_return, + "shares": funding_per_position / trade_b_1["price"], + "close_condition": trade_b_2.get("status", "UNKNOWN"), + "open_disequilibrium": trade_b_1.get("disequilibrium"), + "close_disequilibrium": trade_b_2.get("disequilibrium"), + }) + + if day_roundtrips: + roundtrip_trades_by_day[day] = day_roundtrips + + return roundtrip_trades_by_day + + def print_returns_by_day(self) -> None: + """ + Print detailed return information for each day, grouped by day. + Shows individual symbol round-trips and daily totals. + """ + roundtrip_trades = self.extract_roundtrip_trades() + + if not roundtrip_trades: + print("\n====== NO ROUND-TRIP TRADES FOUND ======") + return + + print("\n====== PAIR RESEARCH RETURNS BY DAY ======") + + total_return_all_days = 0.0 + + for day in sorted(roundtrip_trades.keys()): + day_trades = roundtrip_trades[day] + + print(f"\n--- {day} ---") + + day_total_return = 0.0 + pair_returns = [] + + # Group trades by pair (every 2 trades form a pair) + for i in range(0, len(day_trades), 2): + if i + 1 < len(day_trades): + trade_a = day_trades[i] + trade_b = day_trades[i + 1] + + # Print individual symbol results + print(f" {trade_a['open_time'].time()}-{trade_a['close_time'].time()}") + print(f" {trade_a['symbol']}: {trade_a['open_side']} @ ${trade_a['open_price']:.2f} → " + f"{trade_a['close_side']} @ ${trade_a['close_price']:.2f} | " + f"Return: {trade_a['symbol_return']:+.2f}% | Shares: {trade_a['shares']:.2f}") + + print(f" {trade_b['symbol']}: {trade_b['open_side']} @ ${trade_b['open_price']:.2f} → " + f"{trade_b['close_side']} @ ${trade_b['close_price']:.2f} | " + f"Return: {trade_b['symbol_return']:+.2f}% | Shares: {trade_b['shares']:.2f}") + + # Show disequilibrium info if available + if trade_a.get('open_disequilibrium') is not None: + print(f" Disequilibrium: Open: {trade_a['open_disequilibrium']:.4f}, " + f"Close: {trade_a['close_disequilibrium']:.4f}") + + pair_return = trade_a['pair_return'] + print(f" Pair Return: {pair_return:+.2f}% | Close Condition: {trade_a['close_condition']}") + print() + + pair_returns.append(pair_return) + day_total_return += pair_return + + print(f" Day Total Return: {day_total_return:+.2f}% ({len(pair_returns)} pairs)") + total_return_all_days += day_total_return + + print(f"\n====== TOTAL RETURN ACROSS ALL DAYS ======") + print(f"Total Return: {total_return_all_days:+.2f}%") + print(f"Total Days: {len(roundtrip_trades)}") + if len(roundtrip_trades) > 0: + print(f"Average Daily Return: {total_return_all_days / len(roundtrip_trades):+.2f}%") + + def get_return_summary(self) -> Dict[str, Any]: + """ + Get a summary of returns across all days. + Returns a dictionary with key metrics. + """ + roundtrip_trades = self.extract_roundtrip_trades() + + if not roundtrip_trades: + return { + "total_return": 0.0, + "total_days": 0, + "total_pairs": 0, + "average_daily_return": 0.0, + "best_day": None, + "worst_day": None, + "daily_returns": {} + } + + daily_returns = {} + total_return = 0.0 + total_pairs = 0 + + for day, day_trades in roundtrip_trades.items(): + day_return = 0.0 + day_pairs = len(day_trades) // 2 # Each pair has 2 symbol trades + + for trade in day_trades: + day_return += trade['symbol_return'] + + daily_returns[day] = { + "return": day_return, + "pairs": day_pairs + } + total_return += day_return + total_pairs += day_pairs + + best_day = max(daily_returns.items(), key=lambda x: x[1]["return"]) if daily_returns else None + worst_day = min(daily_returns.items(), key=lambda x: x[1]["return"]) if daily_returns else None + + return { + "total_return": total_return, + "total_days": len(roundtrip_trades), + "total_pairs": total_pairs, + "average_daily_return": total_return / len(roundtrip_trades) if roundtrip_trades else 0.0, + "best_day": best_day, + "worst_day": worst_day, + "daily_returns": daily_returns + } + + def print_single_day_results(self) -> None: + """Print results for all processed days.""" + all_trades_list = self.all_trades + if not all_trades_list: + print("No trades found.") + return + + print(f"Total trades processed: {len(all_trades_list)}") + + # Group trades by day + trades_by_day: Dict[str, List[Dict[str, Any]]] = {} + for trade in all_trades_list: + if trade["timestamp"]: + day = trade["timestamp"].date() + if day not in trades_by_day: + trades_by_day[day] = [] + trades_by_day[day].append(trade) + + for day, day_trades in sorted(trades_by_day.items()): + print(f"\n--- {day} ---") + for trade in day_trades: + print(f" {trade['timestamp'].time() if trade['timestamp'] else 'N/A'}: " + f"{trade['symbol']} {trade['side']} {trade['action']} @ ${trade['price']:.2f} " + f"({trade['status']})") + + def print_grand_totals(self) -> None: + """Print grand totals for the single pair analysis.""" + summary = self.get_return_summary() + + print(f"\n====== PAIR RESEARCH GRAND TOTALS ======") + print(f"Total Return: {summary['total_return']:+.2f}%") + print(f"Total Days Traded: {summary['total_days']}") + print(f"Total Pair Trades: {summary['total_pairs']}") + + if summary['total_days'] > 0: + print(f"Average Daily Return: {summary['average_daily_return']:+.2f}%") + + if summary['best_day']: + best_day, best_data = summary['best_day'] + print(f"Best Day: {best_day} ({best_data['return']:+.2f}%)") + + if summary['worst_day']: + worst_day, worst_data = summary['worst_day'] + print(f"Worst Day: {worst_day} ({worst_data['return']:+.2f}%)") + + # Update the total_realized_pnl for backward compatibility + self.total_realized_pnl = summary['total_return'] + + def analyze_pair_performance(self) -> None: + """ + Main method to perform comprehensive pair research analysis. + Extracts round-trip trades, calculates returns, groups by day, and prints results. + """ + print(f"\n{'='*60}") + print(f"PAIR RESEARCH PERFORMANCE ANALYSIS") + print(f"{'='*60}") + + # Calculate returns first + self.calculate_returns() + + # Print detailed returns by day + self.print_returns_by_day() + + # Print outstanding positions if any + self.print_outstanding_positions() + + # Print grand totals + self.print_grand_totals() + + # Print additional analysis + self._print_additional_metrics() + + def _print_additional_metrics(self) -> None: + """Print additional performance metrics.""" + summary = self.get_return_summary() + + if summary['total_days'] == 0: + return + + print(f"\n====== ADDITIONAL METRICS ======") + + # Calculate win rate + winning_days = sum(1 for day_data in summary['daily_returns'].values() if day_data['return'] > 0) + win_rate = (winning_days / summary['total_days']) * 100 + print(f"Winning Days: {winning_days}/{summary['total_days']} ({win_rate:.1f}%)") + + # Calculate average trade return + if summary['total_pairs'] > 0: + # Each pair has 2 symbol trades, so total symbol trades = total_pairs * 2 + total_symbol_trades = summary['total_pairs'] * 2 + avg_symbol_return = summary['total_return'] / total_symbol_trades + print(f"Average Symbol Return: {avg_symbol_return:+.2f}%") + + avg_pair_return = summary['total_return'] / summary['total_pairs'] / 2 # Divide by 2 since we sum both symbols + print(f"Average Pair Return: {avg_pair_return:+.2f}%") + + # Show daily return distribution + daily_returns_list = [data['return'] for data in summary['daily_returns'].values()] + if daily_returns_list: + print(f"Daily Return Range: {min(daily_returns_list):+.2f}% to {max(daily_returns_list):+.2f}%") + + + def print_outstanding_positions(self) -> None: + """Print outstanding positions for the single pair.""" + all_positions = self.outstanding_positions + if not all_positions: + print("\n====== NO OUTSTANDING POSITIONS ======") + return + + print(f"\n====== OUTSTANDING POSITIONS ======") + print(f"{'Symbol':<10} {'Side':<4} {'Shares':<10} {'Open $':<8} {'Current $':<10} {'Value $':<12}") + print("-" * 70) + + total_value = 0.0 + for pos in all_positions: + current_value = pos.get("last_value", 0.0) + print(f"{pos['symbol']:<10} {pos['open_side']:<4} {pos['shares']:<10.2f} " + f"{pos['open_px']:<8.2f} {pos['last_px']:<10.2f} {current_value:<12.2f}") + total_value += current_value + + print("-" * 70) + print(f"{'TOTAL VALUE':<60} ${total_value:<12.2f}") + + def get_total_realized_pnl(self) -> float: + """Get total realized PnL.""" + return self.total_realized_pnl + + def get_outstanding_positions(self) -> List[Dict[str, Any]]: + """Get outstanding positions.""" + return self.outstanding_positions + diff --git a/lib/pt_strategy/trading_pair.py b/lib/pt_strategy/trading_pair.py new file mode 100644 index 0000000..0ab13a9 --- /dev/null +++ b/lib/pt_strategy/trading_pair.py @@ -0,0 +1,170 @@ +from __future__ import annotations + +from abc import ABC, abstractmethod +from datetime import datetime +from enum import Enum +from typing import Any, Dict, Optional, Type, cast, Generator, List + +import pandas as pd + +from pt_strategy.model_data_policy import DataParams + + +class PairState(Enum): + INITIAL = 1 + OPEN = 2 + CLOSE = 3 + CLOSE_POSITION = 4 + CLOSE_STOP_LOSS = 5 + CLOSE_STOP_PROFIT = 6 + +class TradingPair: + config_: Dict[str, Any] + market_data_: pd.DataFrame + symbol_a_: str + symbol_b_: str + + stat_model_price_: str + model_: PairsTradingModel # type: ignore[assignment] + model_tdp_: ModelDataPolicy # type: ignore[assignment] + + user_data_: Dict[str, Any] + + def __init__( + self, + config: Dict[str, Any], + instruments: List[Dict[str, str]], + ): + + from pt_strategy.model_data_policy import ModelDataPolicy + from pt_strategy.pt_model import PairsTradingModel + assert len(instruments) == 2, "Trading pair must have exactly 2 instruments" + + self.config_ = config + self.symbol_a_ = instruments[0]["symbol"] + self.symbol_b_ = instruments[1]["symbol"] + self.model_ = PairsTradingModel.create(config) + self.model_tdp_ = ModelDataPolicy.create(config) + self.stat_model_price_ = config["stat_model_price"] + self.user_data_ = { + "state": PairState.INITIAL, + } + + def colnames(self) -> List[str]: + return [ + f"{self.stat_model_price_}_{self.symbol_a_}", + f"{self.stat_model_price_}_{self.symbol_b_}", + ] + + def exec_prices_colnames(self) -> List[str]: + return [ + f"exec_price_{self.symbol_a_}", + f"exec_price_{self.symbol_b_}", + ] + + def to_stop_close_conditions(self, predicted_row: pd.Series) -> bool: + config = self.config_ + if ( + "stop_close_conditions" not in config + or config["stop_close_conditions"] is None + ): + return False + if "profit" in config["stop_close_conditions"]: + current_return = self._current_return(predicted_row) + # + # print(f"time={predicted_row['tstamp']} current_return={current_return}") + # + if current_return >= config["stop_close_conditions"]["profit"]: + print(f"STOP PROFIT: {current_return}") + self.user_data_["stop_close_state"] = PairState.CLOSE_STOP_PROFIT + return True + if "loss" in config["stop_close_conditions"]: + if current_return <= config["stop_close_conditions"]["loss"]: + print(f"STOP LOSS: {current_return}") + self.user_data_["stop_close_state"] = PairState.CLOSE_STOP_LOSS + return True + return False + + def _current_return(self, predicted_row: pd.Series) -> float: + if "open_trades" in self.user_data_: + open_trades = self.user_data_["open_trades"] + if len(open_trades) == 0: + return 0.0 + + def _single_instrument_return(symbol: str) -> float: + instrument_open_trades = open_trades[open_trades["symbol"] == symbol] + instrument_open_price = instrument_open_trades["price"].iloc[0] + + sign = -1 if instrument_open_trades["side"].iloc[0] == "SELL" else 1 + instrument_price = predicted_row[f"{self.stat_model_price_}_{symbol}"] + instrument_return = ( + sign + * (instrument_price - instrument_open_price) + / instrument_open_price + ) + return float(instrument_return) * 100.0 + + instrument_a_return = _single_instrument_return(self.symbol_a_) + instrument_b_return = _single_instrument_return(self.symbol_b_) + return instrument_a_return + instrument_b_return + return 0.0 + + def on_open_trades(self, trades: pd.DataFrame) -> None: + if "close_trades" in self.user_data_: + del self.user_data_["close_trades"] + self.user_data_["open_trades"] = trades + + def on_close_trades(self, trades: pd.DataFrame) -> None: + del self.user_data_["open_trades"] + self.user_data_["close_trades"] = trades + + def add_outstanding_position( + self, + symbol: str, + open_side: str, + open_px: float, + open_tstamp: datetime, + last_mkt_data_row: pd.Series, + ) -> None: + assert symbol in [self.symbol_a_, self.symbol_b_], "Symbol must be one of the pair's symbols" + assert open_side in ["BUY", "SELL"], "Open side must be either BUY or SELL" + assert open_px > 0, "Open price must be greater than 0" + assert open_tstamp is not None, "Open timestamp must be provided" + assert last_mkt_data_row is not None, "Last market data row must be provided" + + exec_prices_col_a, exec_prices_col_b = self.exec_prices_colnames() + if symbol == self.symbol_a_: + last_px = last_mkt_data_row[exec_prices_col_a] + else: + last_px = last_mkt_data_row[exec_prices_col_b] + + + funding_per_position = self.config_["funding_per_pair"] / 2 + shares = funding_per_position / open_px + if open_side == "SELL": + shares = -shares + + if "outstanding_positions" not in self.user_data_: + self.user_data_["outstanding_positions"] = [] + + self.user_data_["outstanding_positions"].append({ + "symbol": symbol, + "open_side": open_side, + "open_px": open_px, + "shares": shares, + "open_tstamp": open_tstamp, + "last_px": last_px, + "last_tstamp": last_mkt_data_row["tstamp"], + "last_value": last_px * shares, + }) + + + def run(self, market_data: pd.DataFrame, data_params: DataParams) -> Prediction: # type: ignore[assignment] + self.market_data_ = market_data[data_params.training_start_index:data_params.training_start_index + data_params.training_size] + return self.model_.predict(pair=self) + + while self.model_tdp_.has_next_training_data(): + training_data = self.model_tdp_.get_next_training_data() + + + diff --git a/lib/pt_strategy/trading_strategy.py b/lib/pt_strategy/trading_strategy.py new file mode 100644 index 0000000..82c28f1 --- /dev/null +++ b/lib/pt_strategy/trading_strategy.py @@ -0,0 +1,416 @@ +from __future__ import annotations + +import os +from abc import ABC, abstractmethod +from enum import Enum +from typing import Any, Dict, Generator, List, Optional, Type, cast + +import pandas as pd +from pt_strategy.model_data_policy import ModelDataPolicy +from pt_strategy.pt_market_data import PtMarketData +from pt_strategy.pt_model import Prediction +from pt_strategy.results import ( + PairResearchResult, + create_result_database, + store_config_in_database, +) +from pt_strategy.trading_pair import PairState, TradingPair +from tools.filetools import resolve_datafiles +from tools.instruments import get_instruments + + +class PtResearchStrategy: + config_: Dict[str, Any] + trading_pair_: TradingPair + model_data_policy_: ModelDataPolicy + pt_mkt_data_: PtMarketData + + trades_: List[pd.DataFrame] + + def __init__( + self, + config: Dict[str, Any], + datafiles: List[str], + instruments: List[Dict[str, str]], + ): + from pt_strategy.model_data_policy import ModelDataPolicy + from pt_strategy.pt_market_data import PtMarketData, ResearchMarketData + from pt_strategy.trading_pair import TradingPair + + self.config_ = config + self.trades_ = [] + self.trading_pair_ = TradingPair(config=config, instruments=instruments) + self.model_data_policy_ = ModelDataPolicy.create(config) + + import copy + + # modified config must be passed to PtMarketData + config_copy = copy.deepcopy(config) + config_copy["instruments"] = instruments + config_copy["datafiles"] = datafiles + self.pt_mkt_data_ = PtMarketData.create( + config=config_copy, md_class=ResearchMarketData + ) + self.pt_mkt_data_.load() + + def outstanding_positions(self) -> List[Dict[str, Any]]: + return list(self.trading_pair_.user_data_.get("outstanding_positions", [])) + + def run(self) -> None: + training_minutes = self.config_.get("training_minutes", 120) + market_data_series: pd.Series + market_data_df = pd.DataFrame() + + idx = 0 + while self.pt_mkt_data_.has_next(): + market_data_series = self.pt_mkt_data_.get_next() + market_data_df = pd.concat( + [market_data_df, market_data_series.to_frame().T], ignore_index=True + ) + if idx >= training_minutes: + break + idx += 1 + + assert idx >= training_minutes, "Not enough training data" + + while self.pt_mkt_data_.has_next(): + + market_data_series = self.pt_mkt_data_.get_next() + new_row = market_data_series.to_frame().T + market_data_df = pd.concat([market_data_df, new_row], ignore_index=True) + + prediction = self.trading_pair_.run( + market_data_df, self.model_data_policy_.advance() + ) + assert prediction is not None + + trades = self._create_trades( + prediction=prediction, last_row=market_data_df.iloc[-1] + ) + if trades is not None: + self.trades_.append(trades) + + trades = self._handle_outstanding_positions() + if trades is not None: + self.trades_.append(trades) + + def _create_trades( + self, prediction: Prediction, last_row: pd.Series + ) -> Optional[pd.DataFrame]: + pair = self.trading_pair_ + trades = None + + open_threshold = self.config_["dis-equilibrium_open_trshld"] + close_threshold = self.config_["dis-equilibrium_close_trshld"] + scaled_disequilibrium = prediction.scaled_disequilibrium_ + abs_scaled_disequilibrium = abs(scaled_disequilibrium) + + if pair.user_data_["state"] in [ + PairState.INITIAL, + PairState.CLOSE, + PairState.CLOSE_POSITION, + PairState.CLOSE_STOP_LOSS, + PairState.CLOSE_STOP_PROFIT, + ]: + if abs_scaled_disequilibrium >= open_threshold: + trades = self._create_open_trades( + pair, row=last_row, prediction=prediction + ) + if trades is not None: + trades["status"] = PairState.OPEN.name + print(f"OPEN TRADES:\n{trades}") + pair.user_data_["state"] = PairState.OPEN + pair.on_open_trades(trades) + + elif pair.user_data_["state"] == PairState.OPEN: + if abs_scaled_disequilibrium <= close_threshold: + trades = self._create_close_trades( + pair, row=last_row, prediction=prediction + ) + if trades is not None: + trades["status"] = PairState.CLOSE.name + print(f"CLOSE TRADES:\n{trades}") + pair.user_data_["state"] = PairState.CLOSE + pair.on_close_trades(trades) + elif pair.to_stop_close_conditions(predicted_row=last_row): + trades = self._create_close_trades(pair, row=last_row) + if trades is not None: + trades["status"] = pair.user_data_["stop_close_state"].name + print(f"STOP CLOSE TRADES:\n{trades}") + pair.user_data_["state"] = pair.user_data_["stop_close_state"] + pair.on_close_trades(trades) + + return trades + + def _handle_outstanding_positions(self) -> Optional[pd.DataFrame]: + trades = None + pair = self.trading_pair_ + + # Outstanding positions + if pair.user_data_["state"] == PairState.OPEN: + print(f"{pair}: *** Position is NOT CLOSED. ***") + # outstanding positions + if self.config_["close_outstanding_positions"]: + close_position_row = pd.Series(pair.market_data_.iloc[-2]) + # close_position_row["disequilibrium"] = 0.0 + # close_position_row["scaled_disequilibrium"] = 0.0 + # close_position_row["signed_scaled_disequilibrium"] = 0.0 + + trades = self._create_close_trades( + pair=pair, row=close_position_row, prediction=None + ) + if trades is not None: + trades["status"] = PairState.CLOSE_POSITION.name + print(f"CLOSE_POSITION TRADES:\n{trades}") + pair.user_data_["state"] = PairState.CLOSE_POSITION + pair.on_close_trades(trades) + else: + pair.add_outstanding_position( + symbol=pair.symbol_a_, + open_side=pair.user_data_["open_side_a"], + open_px=pair.user_data_["open_px_a"], + open_tstamp=pair.user_data_["open_tstamp"], + last_mkt_data_row=pair.market_data_.iloc[-1], + ) + pair.add_outstanding_position( + symbol=pair.symbol_b_, + open_side=pair.user_data_["open_side_b"], + open_px=pair.user_data_["open_px_b"], + open_tstamp=pair.user_data_["open_tstamp"], + last_mkt_data_row=pair.market_data_.iloc[-1], + ) + return trades + + def _trades_df(self) -> pd.DataFrame: + types = { + "time": "datetime64[ns]", + "action": "string", + "symbol": "string", + "side": "string", + "price": "float64", + "disequilibrium": "float64", + "scaled_disequilibrium": "float64", + "signed_scaled_disequilibrium": "float64", + # "pair": "object", + } + columns = list(types.keys()) + return pd.DataFrame(columns=columns).astype(types) + + def _create_open_trades( + self, pair: TradingPair, row: pd.Series, prediction: Prediction + ) -> Optional[pd.DataFrame]: + colname_a, colname_b = pair.exec_prices_colnames() + + tstamp = row["tstamp"] + diseqlbrm = prediction.disequilibrium_ + scaled_disequilibrium = prediction.scaled_disequilibrium_ + px_a = row[f"{colname_a}"] + px_b = row[f"{colname_b}"] + + # creating the trades + df = self._trades_df() + + print(f"OPEN_TRADES: {row["tstamp"]} {scaled_disequilibrium=}") + if diseqlbrm > 0: + side_a = "SELL" + side_b = "BUY" + else: + side_a = "BUY" + side_b = "SELL" + + # save closing sides + pair.user_data_["open_side_a"] = side_a # used in oustanding positions + pair.user_data_["open_side_b"] = side_b + pair.user_data_["open_px_a"] = px_a + pair.user_data_["open_px_b"] = px_b + pair.user_data_["open_tstamp"] = tstamp + + pair.user_data_["close_side_a"] = side_b # used for closing trades + pair.user_data_["close_side_b"] = side_a + + # create opening trades + df.loc[len(df)] = { + "time": tstamp, + "symbol": pair.symbol_a_, + "side": side_a, + "action": "OPEN", + "price": px_a, + "disequilibrium": diseqlbrm, + "signed_scaled_disequilibrium": scaled_disequilibrium, + "scaled_disequilibrium": abs(scaled_disequilibrium), + # "pair": pair, + } + df.loc[len(df)] = { + "time": tstamp, + "symbol": pair.symbol_b_, + "side": side_b, + "action": "OPEN", + "price": px_b, + "disequilibrium": diseqlbrm, + "scaled_disequilibrium": abs(scaled_disequilibrium), + "signed_scaled_disequilibrium": scaled_disequilibrium, + # "pair": pair, + } + return df + + def _create_close_trades( + self, pair: TradingPair, row: pd.Series, prediction: Optional[Prediction] = None + ) -> Optional[pd.DataFrame]: + colname_a, colname_b = pair.exec_prices_colnames() + + tstamp = row["tstamp"] + if prediction is not None: + diseqlbrm = prediction.disequilibrium_ + signed_scaled_disequilibrium = prediction.scaled_disequilibrium_ + scaled_disequilibrium = abs(prediction.scaled_disequilibrium_) + else: + diseqlbrm = 0.0 + signed_scaled_disequilibrium = 0.0 + scaled_disequilibrium = 0.0 + px_a = row[f"{colname_a}"] + px_b = row[f"{colname_b}"] + + # creating the trades + df = self._trades_df() + + # create opening trades + df.loc[len(df)] = { + "time": tstamp, + "symbol": pair.symbol_a_, + "side": pair.user_data_["close_side_a"], + "action": "CLOSE", + "price": px_a, + "disequilibrium": diseqlbrm, + "scaled_disequilibrium": scaled_disequilibrium, + "signed_scaled_disequilibrium": signed_scaled_disequilibrium, + # "pair": pair, + } + df.loc[len(df)] = { + "time": tstamp, + "symbol": pair.symbol_b_, + "side": pair.user_data_["close_side_b"], + "action": "CLOSE", + "price": px_b, + "disequilibrium": diseqlbrm, + "scaled_disequilibrium": scaled_disequilibrium, + "signed_scaled_disequilibrium": signed_scaled_disequilibrium, + # "pair": pair, + } + del pair.user_data_["close_side_a"] + del pair.user_data_["close_side_b"] + + del pair.user_data_["open_tstamp"] + del pair.user_data_["open_px_a"] + del pair.user_data_["open_px_b"] + del pair.user_data_["open_side_a"] + del pair.user_data_["open_side_b"] + return df + + def day_trades(self) -> pd.DataFrame: + return pd.concat(self.trades_, ignore_index=True) + + +def main() -> None: + import argparse + + from tools.config import expand_filename, load_config + + 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( + "--date_pattern", + type=str, + required=True, + help="Date YYYYMMDD, allows * and ? wildcards", + ) + parser.add_argument( + "--instruments", + type=str, + required=True, + help="Comma-separated list of instrument symbols (e.g., COIN:EQUITY,GBTC:CRYPTO)", + ) + parser.add_argument( + "--result_db", + type=str, + required=True, + help="Path to SQLite database for storing results. Use 'NONE' to disable database output.", + ) + + args = parser.parse_args() + + config: Dict = load_config(args.config) + + # Resolve data files (CLI takes priority over config) + instruments = get_instruments(args, config) + datafiles = resolve_datafiles(config, args.date_pattern, instruments) + + days = list(set([day for day, _ in datafiles])) + print(f"Found {len(datafiles)} data files to process:") + for df in datafiles: + print(f" - {df}") + + # 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]] = {} + is_config_stored = False + # Process each data file + + results = PairResearchResult(config=config) + for day in sorted(days): + md_datafiles = [datafile for md_day, datafile in datafiles if md_day == day] + if not all([os.path.exists(datafile) for datafile in md_datafiles]): + print(f"WARNING: insufficient data files: {md_datafiles}") + continue + print(f"\n====== Processing {day} ======") + + if not is_config_stored: + store_config_in_database( + db_path=args.result_db, + config_file_path=args.config, + config=config, + datafiles=datafiles, + instruments=instruments, + ) + is_config_stored = True + + pt_strategy = PtResearchStrategy( + config=config, datafiles=md_datafiles, instruments=instruments + ) + pt_strategy.run() + results.add_day_results( + day=day, + trades=pt_strategy.day_trades(), + outstanding_positions=pt_strategy.outstanding_positions(), + ) + + # ADD RESULTS ANALYSIS + results.calculate_returns() + results.print_single_day_results() + + # Store results with day name as key + # filename = os.path.basename(day) + # all_results[filename] = { + # "trades": pt_strategy.trades_.copy(), + # "outstanding_positions": pt_strategy.outstanding_positions_.copy(), + # } + + # print(f"Successfully processed {filename}") + + results.calculate_returns() + results.print_grand_totals() + results.print_outstanding_positions() + + if args.result_db.upper() != "NONE": + print(f"\nResults stored in database: {args.result_db}") + else: + print("No results to display.") + + +if __name__ == "__main__": + main() diff --git a/lib/pt_trading/expanding_window_fit.py b/lib/pt_trading/expanding_window_fit.py new file mode 100644 index 0000000..1cd57ce --- /dev/null +++ b/lib/pt_trading/expanding_window_fit.py @@ -0,0 +1,304 @@ +from abc import ABC, abstractmethod +from enum import Enum +from typing import Any, Dict, Optional, cast + +import pandas as pd # type: ignore[import] +from pt_trading.fit_method import PairsTradingFitMethod +from pt_trading.results import BacktestResult +from pt_trading.trading_pair import PairState, TradingPair + +NanoPerMin = 1e9 + +class ExpandingWindowFit(PairsTradingFitMethod): + """ + N O T E: + ========= + - This class remains to be abstract + - The following methods are to be implemented in the subclass: + - create_trading_pair() + ========= + """ + + def __init__(self) -> None: + super().__init__() + + def run_pair( + self, pair: TradingPair, bt_result: BacktestResult + ) -> Optional[pd.DataFrame]: + print(f"***{pair}*** STARTING....") + config = pair.config_ + + start_idx = pair.get_begin_index() + end_index = pair.get_end_index() + + pair.user_data_["state"] = PairState.INITIAL + # Initialize trades DataFrame with proper dtypes to avoid concatenation warnings + pair.user_data_["trades"] = pd.DataFrame(columns=self.TRADES_COLUMNS).astype( + { + "time": "datetime64[ns]", + "symbol": "string", + "side": "string", + "action": "string", + "price": "float64", + "disequilibrium": "float64", + "scaled_disequilibrium": "float64", + "pair": "object", + } + ) + + training_minutes = config["training_minutes"] + while training_minutes + 1 < end_index: + + pair.get_datasets( + training_minutes=training_minutes, + training_start_index=start_idx, + testing_size=1, + ) + + # ================================ PREDICTION ================================ + try: + self.pair_predict_result_ = pair.predict() + except Exception as e: + raise RuntimeError( + f"{pair}: TrainingPrediction failed: {str(e)}" + ) from e + + training_minutes += 1 + + + self._create_trading_signals(pair, config, bt_result) + print(f"***{pair}*** FINISHED *** Num Trades:{len(pair.user_data_['trades'])}") + + return pair.get_trades() + + def _create_trading_signals( + self, pair: TradingPair, config: Dict, bt_result: BacktestResult + ) -> None: + + predicted_df = self.pair_predict_result_ + assert predicted_df is not None + + open_threshold = config["dis-equilibrium_open_trshld"] + close_threshold = config["dis-equilibrium_close_trshld"] + for curr_predicted_row_idx in range(len(predicted_df)): + pred_row = predicted_df.iloc[curr_predicted_row_idx] + scaled_disequilibrium = pred_row["scaled_disequilibrium"] + + if pair.user_data_["state"] in [ + PairState.INITIAL, + PairState.CLOSE, + PairState.CLOSE_POSITION, + PairState.CLOSE_STOP_LOSS, + PairState.CLOSE_STOP_PROFIT, + ]: + if scaled_disequilibrium >= open_threshold: + open_trades = self._get_open_trades( + pair, row=pred_row, open_threshold=open_threshold + ) + if open_trades is not None: + open_trades["status"] = PairState.OPEN.name + print(f"OPEN TRADES:\n{open_trades}") + pair.add_trades(open_trades) + pair.user_data_["state"] = PairState.OPEN + pair.on_open_trades(open_trades) + + elif pair.user_data_["state"] == PairState.OPEN: + if scaled_disequilibrium <= close_threshold: + close_trades = self._get_close_trades( + pair, row=pred_row, close_threshold=close_threshold + ) + if close_trades is not None: + close_trades["status"] = PairState.CLOSE.name + print(f"CLOSE TRADES:\n{close_trades}") + pair.add_trades(close_trades) + pair.user_data_["state"] = PairState.CLOSE + pair.on_close_trades(close_trades) + elif pair.to_stop_close_conditions(predicted_row=pred_row): + close_trades = self._get_close_trades( + pair, row=pred_row, close_threshold=close_threshold + ) + if close_trades is not None: + close_trades["status"] = pair.user_data_[ + "stop_close_state" + ].name + print(f"STOP CLOSE TRADES:\n{close_trades}") + pair.add_trades(close_trades) + pair.user_data_["state"] = pair.user_data_["stop_close_state"] + pair.on_close_trades(close_trades) + + # Outstanding positions + if pair.user_data_["state"] == PairState.OPEN: + print(f"{pair}: *** Position is NOT CLOSED. ***") + # outstanding positions + if config["close_outstanding_positions"]: + close_position_row = pd.Series(pair.market_data_.iloc[-2]) + close_position_row["disequilibrium"] = 0.0 + close_position_row["scaled_disequilibrium"] = 0.0 + close_position_row["signed_scaled_disequilibrium"] = 0.0 + + close_position_trades = self._get_close_trades( + pair=pair, row=close_position_row, close_threshold=close_threshold + ) + if close_position_trades is not None: + close_position_trades["status"] = PairState.CLOSE_POSITION.name + print(f"CLOSE_POSITION TRADES:\n{close_position_trades}") + pair.add_trades(close_position_trades) + pair.user_data_["state"] = PairState.CLOSE_POSITION + pair.on_close_trades(close_position_trades) + else: + if predicted_df is not None: + bt_result.handle_outstanding_position( + pair=pair, + pair_result_df=predicted_df, + last_row_index=0, + open_side_a=pair.user_data_["open_side_a"], + open_side_b=pair.user_data_["open_side_b"], + open_px_a=pair.user_data_["open_px_a"], + open_px_b=pair.user_data_["open_px_b"], + open_tstamp=pair.user_data_["open_tstamp"], + ) + + def _get_open_trades( + self, pair: TradingPair, row: pd.Series, open_threshold: float + ) -> Optional[pd.DataFrame]: + colname_a, colname_b = pair.exec_prices_colnames() + + open_row = row + + open_tstamp = open_row["tstamp"] + open_disequilibrium = open_row["disequilibrium"] + open_scaled_disequilibrium = open_row["scaled_disequilibrium"] + signed_scaled_disequilibrium = open_row["signed_scaled_disequilibrium"] + open_px_a = open_row[f"{colname_a}"] + open_px_b = open_row[f"{colname_b}"] + + # creating the trades + print(f"OPEN_TRADES: {row["tstamp"]} {open_scaled_disequilibrium=}") + if open_disequilibrium > 0: + open_side_a = "SELL" + open_side_b = "BUY" + close_side_a = "BUY" + close_side_b = "SELL" + else: + open_side_a = "BUY" + open_side_b = "SELL" + close_side_a = "SELL" + close_side_b = "BUY" + + # save closing sides + pair.user_data_["open_side_a"] = open_side_a + pair.user_data_["open_side_b"] = open_side_b + pair.user_data_["open_px_a"] = open_px_a + pair.user_data_["open_px_b"] = open_px_b + + pair.user_data_["open_tstamp"] = open_tstamp + + pair.user_data_["close_side_a"] = close_side_a + pair.user_data_["close_side_b"] = close_side_b + + # create opening trades + trd_signal_tuples = [ + ( + open_tstamp, + pair.symbol_a_, + open_side_a, + "OPEN", + open_px_a, + open_disequilibrium, + open_scaled_disequilibrium, + signed_scaled_disequilibrium, + pair, + ), + ( + open_tstamp, + pair.symbol_b_, + open_side_b, + "OPEN", + open_px_b, + open_disequilibrium, + open_scaled_disequilibrium, + signed_scaled_disequilibrium, + pair, + ), + ] + # Create DataFrame with explicit dtypes to avoid concatenation warnings + df = pd.DataFrame( + trd_signal_tuples, + columns=self.TRADES_COLUMNS, + ) + # Ensure consistent dtypes + return df.astype( + { + "time": "datetime64[ns]", + "action": "string", + "symbol": "string", + "price": "float64", + "disequilibrium": "float64", + "scaled_disequilibrium": "float64", + "signed_scaled_disequilibrium": "float64", + "pair": "object", + } + ) + + def _get_close_trades( + self, pair: TradingPair, row: pd.Series, close_threshold: float + ) -> Optional[pd.DataFrame]: + colname_a, colname_b = pair.exec_prices_colnames() + + close_row = row + close_tstamp = close_row["tstamp"] + close_disequilibrium = close_row["disequilibrium"] + close_scaled_disequilibrium = close_row["scaled_disequilibrium"] + signed_scaled_disequilibrium = close_row["signed_scaled_disequilibrium"] + close_px_a = close_row[f"{colname_a}"] + close_px_b = close_row[f"{colname_b}"] + + close_side_a = pair.user_data_["close_side_a"] + close_side_b = pair.user_data_["close_side_b"] + + trd_signal_tuples = [ + ( + close_tstamp, + pair.symbol_a_, + close_side_a, + "CLOSE", + close_px_a, + close_disequilibrium, + close_scaled_disequilibrium, + signed_scaled_disequilibrium, + pair, + ), + ( + close_tstamp, + pair.symbol_b_, + close_side_b, + "CLOSE", + close_px_b, + close_disequilibrium, + close_scaled_disequilibrium, + signed_scaled_disequilibrium, + pair, + ), + ] + + # Add tuples to data frame with explicit dtypes to avoid concatenation warnings + df = pd.DataFrame( + trd_signal_tuples, + columns=self.TRADES_COLUMNS, + ) + # Ensure consistent dtypes + return df.astype( + { + "time": "datetime64[ns]", + "action": "string", + "symbol": "string", + "price": "float64", + "disequilibrium": "float64", + "scaled_disequilibrium": "float64", + "signed_scaled_disequilibrium": "float64", + "pair": "object", + } + ) + + def reset(self) -> None: + pass diff --git a/lib/pt_trading/results.py b/lib/pt_trading/results.py index c30bfa7..048ef6e 100644 --- a/lib/pt_trading/results.py +++ b/lib/pt_trading/results.py @@ -195,6 +195,16 @@ def convert_timestamp(timestamp: Any) -> Optional[datetime]: raise ValueError(f"Unsupported timestamp type: {type(timestamp)}") +class PairResarchResult: + pair_: TradingPair + trades_: Dict[str, Dict[str, Any]] + outstanding_positions_: List[Dict[str, Any]] + def __init__(self, config: Dict[str, Any], pair: TradingPair, trades: Dict[str, Dict[str, Any]], outstanding_positions: List[Dict[str, Any]]): + self.config = config + self.pair_ = pair + self.trades_ = trades + self.outstanding_positions_ = outstanding_positions + class BacktestResult: """ @@ -206,7 +216,7 @@ class BacktestResult: self.trades: Dict[str, Dict[str, Any]] = {} self.total_realized_pnl = 0.0 self.outstanding_positions: List[Dict[str, Any]] = [] - self.pairs_trades_: Dict[str, List[Dict[str, Any]]] = {} + self.symbol_roundtrip_trades_: Dict[str, List[Dict[str, Any]]] = {} def add_trade( self, @@ -334,7 +344,7 @@ class BacktestResult: for filename, data in all_results.items(): pairs = list(data["trades"].keys()) for pair in pairs: - self.pairs_trades_[pair] = [] + self.symbol_roundtrip_trades_[pair] = [] trades_dict = data["trades"][pair] for symbol in trades_dict.keys(): trades.extend(trades_dict[symbol]) @@ -369,7 +379,7 @@ class BacktestResult: pair_return = symbol_a_return + symbol_b_return - self.pairs_trades_[pair].append( + self.symbol_roundtrip_trades_[pair].append( { "symbol": symbol_a, "open_side": trade_a_1["side"], @@ -391,7 +401,7 @@ class BacktestResult: "pair_return": pair_return } ) - self.pairs_trades_[pair].append( + self.symbol_roundtrip_trades_[pair].append( { "symbol": symbol_b, "open_side": trade_b_1["side"], @@ -417,11 +427,11 @@ class BacktestResult: # Print pair returns with disequilibrium information day_return = 0.0 - if pair in self.pairs_trades_: + if pair in self.symbol_roundtrip_trades_: print(f"{pair}:") pair_return = 0.0 - for trd in self.pairs_trades_[pair]: + for trd in self.symbol_roundtrip_trades_[pair]: disequil_info = "" if ( trd["open_scaled_disequilibrium"] is not None @@ -641,7 +651,7 @@ class BacktestResult: for pair_name, _ in trades.items(): # Second pass: insert completed trade records into database - for trade_pair in sorted(self.pairs_trades_[pair_name], key=lambda x: x["open_time"]): + for trade_pair in sorted(self.symbol_roundtrip_trades_[pair_name], key=lambda x: x["open_time"]): # Only store completed trades in pt_bt_results table cursor.execute( """ diff --git a/lib/pt_trading/rolling_window_fit.py b/lib/pt_trading/rolling_window_fit.py index debf63e..aa2c9c7 100644 --- a/lib/pt_trading/rolling_window_fit.py +++ b/lib/pt_trading/rolling_window_fit.py @@ -316,4 +316,4 @@ class RollingFit(PairsTradingFitMethod): ) def reset(self) -> None: - curr_training_start_idx = 0 + pass diff --git a/lib/pt_trading/trading_pair.py b/lib/pt_trading/trading_pair.py index 33d53ea..0a859f8 100644 --- a/lib/pt_trading/trading_pair.py +++ b/lib/pt_trading/trading_pair.py @@ -119,8 +119,8 @@ class TradingPair(ABC): return execution_price_column = self.config_["execution_price"]["column"] execution_price_shift = self.config_["execution_price"]["shift"] - self.market_data_[f"exec_price_{self.symbol_a_}"] = self.market_data_[f"{self.stat_model_price_}_{self.symbol_a_}"].shift(-execution_price_shift) - self.market_data_[f"exec_price_{self.symbol_b_}"] = self.market_data_[f"{self.stat_model_price_}_{self.symbol_b_}"].shift(-execution_price_shift) + self.market_data_[f"exec_price_{self.symbol_a_}"] = self.market_data_[f"{execution_price_column}_{self.symbol_a_}"].shift(-execution_price_shift) + self.market_data_[f"exec_price_{self.symbol_b_}"] = self.market_data_[f"{execution_price_column}_{self.symbol_b_}"].shift(-execution_price_shift) self.market_data_ = self.market_data_.dropna().reset_index(drop=True) diff --git a/lib/tools/filetools.py b/lib/tools/filetools.py new file mode 100644 index 0000000..4c3a6e5 --- /dev/null +++ b/lib/tools/filetools.py @@ -0,0 +1,33 @@ +import os +import glob +from typing import Dict, List, Tuple + +DayT = str +DataFileNameT = str + +def resolve_datafiles( + config: Dict, date_pattern: str, instruments: List[Dict[str, str]] +) -> List[Tuple[DayT, DataFileNameT]]: + resolved_files: List[Tuple[DayT, DataFileNameT]] = [] + for inst in instruments: + pattern = date_pattern + inst_type = inst["instrument_type"] + data_dir = config["market_data_loading"][inst_type]["data_directory"] + if "*" in pattern or "?" in pattern: + # Handle wildcards + if not os.path.isabs(pattern): + pattern = os.path.join(data_dir, f"{pattern}.mktdata.ohlcv.db") + matched_files = glob.glob(pattern) + for matched_file in matched_files: + import re + match = re.search(r"(\d{8})\.mktdata\.ohlcv\.db$", matched_file) + assert match is not None + day = match.group(1) + resolved_files.append((day, matched_file)) + else: + # Handle explicit file path + if not os.path.isabs(pattern): + pattern = os.path.join(data_dir, f"{pattern}.mktdata.ohlcv.db") + resolved_files.append((date_pattern, pattern)) + return sorted(list(set(resolved_files))) # Remove duplicates and sort + diff --git a/lib/tools/instruments.py b/lib/tools/instruments.py new file mode 100644 index 0000000..ea8cddd --- /dev/null +++ b/lib/tools/instruments.py @@ -0,0 +1,21 @@ +import argparse +from typing import Dict, List + +def get_instruments(args: argparse.Namespace, config: Dict) -> List[Dict[str, str]]: + + instruments = [ + { + "symbol": inst.split(":")[0], + "instrument_type": inst.split(":")[1], + "exchange_id": inst.split(":")[2], + "instrument_id_pfx": config["market_data_loading"][inst.split(":")[1]][ + "instrument_id_pfx" + ], + "db_table_name": config["market_data_loading"][inst.split(":")[1]][ + "db_table_name" + ], + } + for inst in args.instruments.split(",") + ] + return instruments + diff --git a/research/notebooks/single_pair_test.ipynb b/research/notebooks/single_pair_test.ipynb index 3117e45..1340ba1 100644 --- a/research/notebooks/single_pair_test.ipynb +++ b/research/notebooks/single_pair_test.ipynb @@ -353,7 +353,7 @@ " ✓ Data file found: ./data/crypto/20250602.mktdata.ohlcv.db\n", "\n", "Created trading pair: ADA-USDT & SOL-USDT\n", - "Market data shape: (540, 5)\n", + "Market data shape: (659, 5)\n", "Column names: ['close_ADA-USDT', 'close_SOL-USDT']\n", "\n", "Sample data:\n" @@ -390,43 +390,43 @@ " \n", " \n", " 0\n", - " 2025-06-02 13:30:00\n", - " 0.6709\n", - " 153.68\n", - " 0.6716\n", - " 153.85\n", + " 2025-06-02 11:30:00\n", + " 0.6670\n", + " 154.01\n", + " 0.6673\n", + " 154.12\n", " \n", " \n", " 1\n", - " 2025-06-02 13:31:00\n", - " 0.6716\n", - " 153.85\n", - " 0.6730\n", - " 153.87\n", + " 2025-06-02 11:31:00\n", + " 0.6673\n", + " 154.12\n", + " 0.6677\n", + " 154.16\n", " \n", " \n", " 2\n", - " 2025-06-02 13:32:00\n", - " 0.6730\n", - " 153.87\n", - " 0.6729\n", - " 153.93\n", + " 2025-06-02 11:32:00\n", + " 0.6677\n", + " 154.16\n", + " 0.6679\n", + " 154.22\n", " \n", " \n", " 3\n", - " 2025-06-02 13:33:00\n", - " 0.6729\n", - " 153.93\n", - " 0.6732\n", - " 154.04\n", + " 2025-06-02 11:33:00\n", + " 0.6679\n", + " 154.22\n", + " 0.6670\n", + " 154.06\n", " \n", " \n", " 4\n", - " 2025-06-02 13:34:00\n", - " 0.6732\n", - " 154.04\n", - " 0.6735\n", - " 154.02\n", + " 2025-06-02 11:34:00\n", + " 0.6670\n", + " 154.06\n", + " 0.6680\n", + " 154.20\n", " \n", " \n", "\n", @@ -434,11 +434,11 @@ ], "text/plain": [ " tstamp close_ADA-USDT close_SOL-USDT exec_price_ADA-USDT exec_price_SOL-USDT\n", - "0 2025-06-02 13:30:00 0.6709 153.68 0.6716 153.85\n", - "1 2025-06-02 13:31:00 0.6716 153.85 0.6730 153.87\n", - "2 2025-06-02 13:32:00 0.6730 153.87 0.6729 153.93\n", - "3 2025-06-02 13:33:00 0.6729 153.93 0.6732 154.04\n", - "4 2025-06-02 13:34:00 0.6732 154.04 0.6735 154.02" + "0 2025-06-02 11:30:00 0.6670 154.01 0.6673 154.12\n", + "1 2025-06-02 11:31:00 0.6673 154.12 0.6677 154.16\n", + "2 2025-06-02 11:32:00 0.6677 154.16 0.6679 154.22\n", + "3 2025-06-02 11:33:00 0.6679 154.22 0.6670 154.06\n", + "4 2025-06-02 11:34:00 0.6670 154.06 0.6680 154.20" ] }, "metadata": {}, @@ -474,7 +474,15 @@ " \n", " \n", " \n", - " 535\n", + " 654\n", + " 2025-06-02 22:25:00\n", + " 0.6919\n", + " 156.70\n", + " 0.6917\n", + " 156.72\n", + " \n", + " \n", + " 655\n", " 2025-06-02 22:26:00\n", " 0.6917\n", " 156.72\n", @@ -482,7 +490,7 @@ " 156.57\n", " \n", " \n", - " 536\n", + " 656\n", " 2025-06-02 22:27:00\n", " 0.6909\n", " 156.57\n", @@ -490,7 +498,7 @@ " 156.65\n", " \n", " \n", - " 537\n", + " 657\n", " 2025-06-02 22:28:00\n", " 0.6908\n", " 156.65\n", @@ -498,32 +506,24 @@ " 156.75\n", " \n", " \n", - " 538\n", + " 658\n", " 2025-06-02 22:29:00\n", " 0.6910\n", " 156.75\n", " 0.6908\n", " 156.70\n", " \n", - " \n", - " 539\n", - " 2025-06-02 22:30:00\n", - " 0.6908\n", - " 156.70\n", - " 0.6902\n", - " 156.63\n", - " \n", " \n", "\n", "" ], "text/plain": [ " tstamp close_ADA-USDT close_SOL-USDT exec_price_ADA-USDT exec_price_SOL-USDT\n", - "535 2025-06-02 22:26:00 0.6917 156.72 0.6909 156.57\n", - "536 2025-06-02 22:27:00 0.6909 156.57 0.6908 156.65\n", - "537 2025-06-02 22:28:00 0.6908 156.65 0.6910 156.75\n", - "538 2025-06-02 22:29:00 0.6910 156.75 0.6908 156.70\n", - "539 2025-06-02 22:30:00 0.6908 156.70 0.6902 156.63" + "654 2025-06-02 22:25:00 0.6919 156.70 0.6917 156.72\n", + "655 2025-06-02 22:26:00 0.6917 156.72 0.6909 156.57\n", + "656 2025-06-02 22:27:00 0.6909 156.57 0.6908 156.65\n", + "657 2025-06-02 22:28:00 0.6908 156.65 0.6910 156.75\n", + "658 2025-06-02 22:29:00 0.6910 156.75 0.6908 156.70" ] }, "metadata": {}, @@ -1499,7 +1499,7 @@ " ✓ Data file found: ./data/crypto/20250602.mktdata.ohlcv.db\n", "\n", "Created trading pair: ADA-USDT & SOL-USDT\n", - "Market data shape: (540, 5)\n", + "Market data shape: (659, 5)\n", "Column names: ['close_ADA-USDT', 'close_SOL-USDT']\n", "\n", "Sample data:\n" @@ -1536,43 +1536,43 @@ " \n", " \n", " 0\n", - " 2025-06-02 13:30:00\n", - " 0.6709\n", - " 153.68\n", - " 0.6716\n", - " 153.85\n", + " 2025-06-02 11:30:00\n", + " 0.6670\n", + " 154.01\n", + " 0.6673\n", + " 154.12\n", " \n", " \n", " 1\n", - " 2025-06-02 13:31:00\n", - " 0.6716\n", - " 153.85\n", - " 0.6730\n", - " 153.87\n", + " 2025-06-02 11:31:00\n", + " 0.6673\n", + " 154.12\n", + " 0.6677\n", + " 154.16\n", " \n", " \n", " 2\n", - " 2025-06-02 13:32:00\n", - " 0.6730\n", - " 153.87\n", - " 0.6729\n", - " 153.93\n", + " 2025-06-02 11:32:00\n", + " 0.6677\n", + " 154.16\n", + " 0.6679\n", + " 154.22\n", " \n", " \n", " 3\n", - " 2025-06-02 13:33:00\n", - " 0.6729\n", - " 153.93\n", - " 0.6732\n", - " 154.04\n", + " 2025-06-02 11:33:00\n", + " 0.6679\n", + " 154.22\n", + " 0.6670\n", + " 154.06\n", " \n", " \n", " 4\n", - " 2025-06-02 13:34:00\n", - " 0.6732\n", - " 154.04\n", - " 0.6735\n", - " 154.02\n", + " 2025-06-02 11:34:00\n", + " 0.6670\n", + " 154.06\n", + " 0.6680\n", + " 154.20\n", " \n", " \n", "\n", @@ -1580,11 +1580,11 @@ ], "text/plain": [ " tstamp close_ADA-USDT close_SOL-USDT exec_price_ADA-USDT exec_price_SOL-USDT\n", - "0 2025-06-02 13:30:00 0.6709 153.68 0.6716 153.85\n", - "1 2025-06-02 13:31:00 0.6716 153.85 0.6730 153.87\n", - "2 2025-06-02 13:32:00 0.6730 153.87 0.6729 153.93\n", - "3 2025-06-02 13:33:00 0.6729 153.93 0.6732 154.04\n", - "4 2025-06-02 13:34:00 0.6732 154.04 0.6735 154.02" + "0 2025-06-02 11:30:00 0.6670 154.01 0.6673 154.12\n", + "1 2025-06-02 11:31:00 0.6673 154.12 0.6677 154.16\n", + "2 2025-06-02 11:32:00 0.6677 154.16 0.6679 154.22\n", + "3 2025-06-02 11:33:00 0.6679 154.22 0.6670 154.06\n", + "4 2025-06-02 11:34:00 0.6670 154.06 0.6680 154.20" ] }, "metadata": {}, @@ -1620,7 +1620,15 @@ " \n", " \n", " \n", - " 535\n", + " 654\n", + " 2025-06-02 22:25:00\n", + " 0.6919\n", + " 156.70\n", + " 0.6917\n", + " 156.72\n", + " \n", + " \n", + " 655\n", " 2025-06-02 22:26:00\n", " 0.6917\n", " 156.72\n", @@ -1628,7 +1636,7 @@ " 156.57\n", " \n", " \n", - " 536\n", + " 656\n", " 2025-06-02 22:27:00\n", " 0.6909\n", " 156.57\n", @@ -1636,7 +1644,7 @@ " 156.65\n", " \n", " \n", - " 537\n", + " 657\n", " 2025-06-02 22:28:00\n", " 0.6908\n", " 156.65\n", @@ -1644,32 +1652,24 @@ " 156.75\n", " \n", " \n", - " 538\n", + " 658\n", " 2025-06-02 22:29:00\n", " 0.6910\n", " 156.75\n", " 0.6908\n", " 156.70\n", " \n", - " \n", - " 539\n", - " 2025-06-02 22:30:00\n", - " 0.6908\n", - " 156.70\n", - " 0.6902\n", - " 156.63\n", - " \n", " \n", "\n", "" ], "text/plain": [ " tstamp close_ADA-USDT close_SOL-USDT exec_price_ADA-USDT exec_price_SOL-USDT\n", - "535 2025-06-02 22:26:00 0.6917 156.72 0.6909 156.57\n", - "536 2025-06-02 22:27:00 0.6909 156.57 0.6908 156.65\n", - "537 2025-06-02 22:28:00 0.6908 156.65 0.6910 156.75\n", - "538 2025-06-02 22:29:00 0.6910 156.75 0.6908 156.70\n", - "539 2025-06-02 22:30:00 0.6908 156.70 0.6902 156.63" + "654 2025-06-02 22:25:00 0.6919 156.70 0.6917 156.72\n", + "655 2025-06-02 22:26:00 0.6917 156.72 0.6909 156.57\n", + "656 2025-06-02 22:27:00 0.6909 156.57 0.6908 156.65\n", + "657 2025-06-02 22:28:00 0.6908 156.65 0.6910 156.75\n", + "658 2025-06-02 22:29:00 0.6910 156.75 0.6908 156.70" ] }, "metadata": {}, @@ -1689,8 +1689,8 @@ "\n", "Rolling window analysis parameters:\n", " Training window size: 120 minutes\n", - " Maximum iterations: 420\n", - " Total analysis time: ~420 minutes\n", + " Maximum iterations: 539\n", + " Total analysis time: ~539 minutes\n", "\n", "Strategy Configuration:\n", " Open threshold: 2\n", @@ -1701,7 +1701,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1711,7 +1711,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1725,20 +1725,29 @@ "text": [ "\n", "Price Statistics:\n", - " ADA-USDT: Mean=$0.68, Std=$0.01\n", - " SOL-USDT: Mean=$153.54, Std=$1.05\n", + " ADA-USDT: Mean=$0.67, Std=$0.01\n", + " SOL-USDT: Mean=$153.58, Std=$0.96\n", " Price Ratio: Mean=0.00, Std=0.00\n", - " Correlation: 0.9240\n", + " Correlation: 0.7415\n", "Running RollingFit analysis...\n", "\n", "=== SLIDING FIT ANALYSIS ===\n", "Processing first 200 iterations for demonstration...\n", "***ADA-USDT & SOL-USDT*** STARTING....\n", - "OPEN_TRADES: 2025-06-02 15:31:00 open_scaled_disequilibrium=2.892080636255072\n", + "OPEN_TRADES: 2025-06-02 13:37:00 open_scaled_disequilibrium=2.1525256289273242\n", "OPEN TRADES:\n", " time symbol side action price disequilibrium scaled_disequilibrium signed_scaled_disequilibrium pair status\n", - "0 2025-06-02 15:31:00 ADA-USDT BUY OPEN 0.6736 -2.892081 2.892081 -2.892081 ADA-USDT & SOL-USDT OPEN\n", - "1 2025-06-02 15:31:00 SOL-USDT SELL OPEN 153.2400 -2.892081 2.892081 -2.892081 ADA-USDT & SOL-USDT OPEN\n", + "0 2025-06-02 13:37:00 ADA-USDT BUY OPEN 0.6754 -2.152526 2.152526 -2.152526 ADA-USDT & SOL-USDT OPEN\n", + "1 2025-06-02 13:37:00 SOL-USDT SELL OPEN 154.3200 -2.152526 2.152526 -2.152526 ADA-USDT & SOL-USDT OPEN\n", + "CLOSE TRADES:\n", + " time symbol side action price disequilibrium scaled_disequilibrium signed_scaled_disequilibrium pair status\n", + "0 2025-06-02 14:37:00 ADA-USDT SELL CLOSE 0.6734 -0.280199 0.280199 -0.280199 ADA-USDT & SOL-USDT CLOSE\n", + "1 2025-06-02 14:37:00 SOL-USDT BUY CLOSE 153.7000 -0.280199 0.280199 -0.280199 ADA-USDT & SOL-USDT CLOSE\n", + "OPEN_TRADES: 2025-06-02 15:09:00 open_scaled_disequilibrium=2.5218125398969375\n", + "OPEN TRADES:\n", + " time symbol side action price disequilibrium scaled_disequilibrium signed_scaled_disequilibrium pair status\n", + "0 2025-06-02 15:09:00 ADA-USDT BUY OPEN 0.6691 -2.521813 2.521813 -2.521813 ADA-USDT & SOL-USDT OPEN\n", + "1 2025-06-02 15:09:00 SOL-USDT SELL OPEN 152.1800 -2.521813 2.521813 -2.521813 ADA-USDT & SOL-USDT OPEN\n", "CLOSE TRADES:\n", " time symbol side action price disequilibrium scaled_disequilibrium signed_scaled_disequilibrium pair status\n", "0 2025-06-02 15:41:00 ADA-USDT SELL CLOSE 0.6734 0.014633 0.014633 0.014633 ADA-USDT & SOL-USDT CLOSE\n", @@ -1786,11 +1795,11 @@ "1 2025-06-02 19:35:00 SOL-USDT SELL OPEN 152.1300 -2.016878 2.016878 -2.016878 ADA-USDT & SOL-USDT OPEN\n", "ADA-USDT & SOL-USDT: *** Position is NOT CLOSED. ***\n", "CLOSE_POSITION TRADES:\n", - " time symbol side action price disequilibrium scaled_disequilibrium signed_scaled_disequilibrium pair status\n", - "0 2025-06-02 22:29:00 ADA-USDT SELL CLOSE 0.6908 0.0 0.0 0.0 ADA-USDT & SOL-USDT CLOSE_POSITION\n", - "1 2025-06-02 22:29:00 SOL-USDT BUY CLOSE 156.7000 0.0 0.0 0.0 ADA-USDT & SOL-USDT CLOSE_POSITION\n", - "***ADA-USDT & SOL-USDT*** FINISHED *** Num Trades:24\n", - "Generated 24 trading signals\n", + " time symbol side action price disequilibrium scaled_disequilibrium signed_scaled_disequilibrium pair status\n", + "0 2025-06-02 22:28:00 ADA-USDT SELL CLOSE 0.691 0.0 0.0 0.0 ADA-USDT & SOL-USDT CLOSE_POSITION\n", + "1 2025-06-02 22:28:00 SOL-USDT BUY CLOSE 156.750 0.0 0.0 0.0 ADA-USDT & SOL-USDT CLOSE_POSITION\n", + "***ADA-USDT & SOL-USDT*** FINISHED *** Num Trades:28\n", + "Generated 28 trading signals\n", "\n", "Strategy execution completed!\n", "\n", @@ -1819,38 +1828,42 @@ "text": [ "=== SLIDING FIT INTERACTIVE VISUALIZATION ===\n", "Note: Rolling Fit strategy visualization with interactive plotly charts\n", - "Using consistent timeline with 540 timestamps\n", - "Timeline range: 2025-06-02 13:30:00 to 2025-06-02 22:30:00\n", + "Using consistent timeline with 659 timestamps\n", + "Timeline range: 2025-06-02 11:30:00 to 2025-06-02 22:29:00\n", "\n", "Symbol_A trades:\n", " time symbol side action price disequilibrium scaled_disequilibrium signed_scaled_disequilibrium pair status\n", - "0 2025-06-02 15:31:00 ADA-USDT BUY OPEN 0.6736 -2.892081 2.892081 -2.892081 ADA-USDT & SOL-USDT OPEN\n", - "2 2025-06-02 15:41:00 ADA-USDT SELL CLOSE 0.6734 0.014633 0.014633 0.014633 ADA-USDT & SOL-USDT CLOSE\n", - "4 2025-06-02 16:44:00 ADA-USDT BUY OPEN 0.6712 -2.364779 2.364779 -2.364779 ADA-USDT & SOL-USDT OPEN\n", - "6 2025-06-02 17:01:00 ADA-USDT SELL CLOSE 0.6744 -0.457250 0.457250 -0.457250 ADA-USDT & SOL-USDT CLOSE\n", - "8 2025-06-02 17:06:00 ADA-USDT BUY OPEN 0.6740 -2.191025 2.191025 -2.191025 ADA-USDT & SOL-USDT OPEN\n", - "10 2025-06-02 17:17:00 ADA-USDT SELL CLOSE 0.6743 -0.152501 0.152501 -0.152501 ADA-USDT & SOL-USDT CLOSE\n", - "12 2025-06-02 17:24:00 ADA-USDT BUY OPEN 0.6759 -2.748538 2.748538 -2.748538 ADA-USDT & SOL-USDT OPEN\n", - "14 2025-06-02 17:35:00 ADA-USDT SELL CLOSE 0.6715 -0.413061 0.413061 -0.413061 ADA-USDT & SOL-USDT CLOSE\n", - "16 2025-06-02 18:02:00 ADA-USDT SELL OPEN 0.6743 2.047229 2.047229 2.047229 ADA-USDT & SOL-USDT OPEN\n", - "18 2025-06-02 18:06:00 ADA-USDT BUY CLOSE 0.6747 -0.089168 0.089168 -0.089168 ADA-USDT & SOL-USDT CLOSE\n", - "20 2025-06-02 19:35:00 ADA-USDT BUY OPEN 0.6721 -2.016878 2.016878 -2.016878 ADA-USDT & SOL-USDT OPEN\n", - "22 2025-06-02 22:29:00 ADA-USDT SELL CLOSE 0.6908 0.000000 0.000000 0.000000 ADA-USDT & SOL-USDT CLOSE_POSITION\n", + "0 2025-06-02 13:37:00 ADA-USDT BUY OPEN 0.6754 -2.152526 2.152526 -2.152526 ADA-USDT & SOL-USDT OPEN\n", + "2 2025-06-02 14:37:00 ADA-USDT SELL CLOSE 0.6734 -0.280199 0.280199 -0.280199 ADA-USDT & SOL-USDT CLOSE\n", + "4 2025-06-02 15:09:00 ADA-USDT BUY OPEN 0.6691 -2.521813 2.521813 -2.521813 ADA-USDT & SOL-USDT OPEN\n", + "6 2025-06-02 15:41:00 ADA-USDT SELL CLOSE 0.6734 0.014633 0.014633 0.014633 ADA-USDT & SOL-USDT CLOSE\n", + "8 2025-06-02 16:44:00 ADA-USDT BUY OPEN 0.6712 -2.364779 2.364779 -2.364779 ADA-USDT & SOL-USDT OPEN\n", + "10 2025-06-02 17:01:00 ADA-USDT SELL CLOSE 0.6744 -0.457250 0.457250 -0.457250 ADA-USDT & SOL-USDT CLOSE\n", + "12 2025-06-02 17:06:00 ADA-USDT BUY OPEN 0.6740 -2.191025 2.191025 -2.191025 ADA-USDT & SOL-USDT OPEN\n", + "14 2025-06-02 17:17:00 ADA-USDT SELL CLOSE 0.6743 -0.152501 0.152501 -0.152501 ADA-USDT & SOL-USDT CLOSE\n", + "16 2025-06-02 17:24:00 ADA-USDT BUY OPEN 0.6759 -2.748538 2.748538 -2.748538 ADA-USDT & SOL-USDT OPEN\n", + "18 2025-06-02 17:35:00 ADA-USDT SELL CLOSE 0.6715 -0.413061 0.413061 -0.413061 ADA-USDT & SOL-USDT CLOSE\n", + "20 2025-06-02 18:02:00 ADA-USDT SELL OPEN 0.6743 2.047229 2.047229 2.047229 ADA-USDT & SOL-USDT OPEN\n", + "22 2025-06-02 18:06:00 ADA-USDT BUY CLOSE 0.6747 -0.089168 0.089168 -0.089168 ADA-USDT & SOL-USDT CLOSE\n", + "24 2025-06-02 19:35:00 ADA-USDT BUY OPEN 0.6721 -2.016878 2.016878 -2.016878 ADA-USDT & SOL-USDT OPEN\n", + "26 2025-06-02 22:28:00 ADA-USDT SELL CLOSE 0.6910 0.000000 0.000000 0.000000 ADA-USDT & SOL-USDT CLOSE_POSITION\n", "\n", "Symbol_B trades:\n", " time symbol side action price disequilibrium scaled_disequilibrium signed_scaled_disequilibrium pair status\n", - "1 2025-06-02 15:31:00 SOL-USDT SELL OPEN 153.24 -2.892081 2.892081 -2.892081 ADA-USDT & SOL-USDT OPEN\n", - "3 2025-06-02 15:41:00 SOL-USDT BUY CLOSE 153.10 0.014633 0.014633 0.014633 ADA-USDT & SOL-USDT CLOSE\n", - "5 2025-06-02 16:44:00 SOL-USDT SELL OPEN 152.51 -2.364779 2.364779 -2.364779 ADA-USDT & SOL-USDT OPEN\n", - "7 2025-06-02 17:01:00 SOL-USDT BUY CLOSE 153.07 -0.457250 0.457250 -0.457250 ADA-USDT & SOL-USDT CLOSE\n", - "9 2025-06-02 17:06:00 SOL-USDT SELL OPEN 153.03 -2.191025 2.191025 -2.191025 ADA-USDT & SOL-USDT OPEN\n", - "11 2025-06-02 17:17:00 SOL-USDT BUY CLOSE 153.09 -0.152501 0.152501 -0.152501 ADA-USDT & SOL-USDT CLOSE\n", - "13 2025-06-02 17:24:00 SOL-USDT SELL OPEN 153.70 -2.748538 2.748538 -2.748538 ADA-USDT & SOL-USDT OPEN\n", - "15 2025-06-02 17:35:00 SOL-USDT BUY CLOSE 152.99 -0.413061 0.413061 -0.413061 ADA-USDT & SOL-USDT CLOSE\n", - "17 2025-06-02 18:02:00 SOL-USDT BUY OPEN 153.64 2.047229 2.047229 2.047229 ADA-USDT & SOL-USDT OPEN\n", - "19 2025-06-02 18:06:00 SOL-USDT SELL CLOSE 153.84 -0.089168 0.089168 -0.089168 ADA-USDT & SOL-USDT CLOSE\n", - "21 2025-06-02 19:35:00 SOL-USDT SELL OPEN 152.13 -2.016878 2.016878 -2.016878 ADA-USDT & SOL-USDT OPEN\n", - "23 2025-06-02 22:29:00 SOL-USDT BUY CLOSE 156.70 0.000000 0.000000 0.000000 ADA-USDT & SOL-USDT CLOSE_POSITION\n" + "1 2025-06-02 13:37:00 SOL-USDT SELL OPEN 154.32 -2.152526 2.152526 -2.152526 ADA-USDT & SOL-USDT OPEN\n", + "3 2025-06-02 14:37:00 SOL-USDT BUY CLOSE 153.70 -0.280199 0.280199 -0.280199 ADA-USDT & SOL-USDT CLOSE\n", + "5 2025-06-02 15:09:00 SOL-USDT SELL OPEN 152.18 -2.521813 2.521813 -2.521813 ADA-USDT & SOL-USDT OPEN\n", + "7 2025-06-02 15:41:00 SOL-USDT BUY CLOSE 153.10 0.014633 0.014633 0.014633 ADA-USDT & SOL-USDT CLOSE\n", + "9 2025-06-02 16:44:00 SOL-USDT SELL OPEN 152.51 -2.364779 2.364779 -2.364779 ADA-USDT & SOL-USDT OPEN\n", + "11 2025-06-02 17:01:00 SOL-USDT BUY CLOSE 153.07 -0.457250 0.457250 -0.457250 ADA-USDT & SOL-USDT CLOSE\n", + "13 2025-06-02 17:06:00 SOL-USDT SELL OPEN 153.03 -2.191025 2.191025 -2.191025 ADA-USDT & SOL-USDT OPEN\n", + "15 2025-06-02 17:17:00 SOL-USDT BUY CLOSE 153.09 -0.152501 0.152501 -0.152501 ADA-USDT & SOL-USDT CLOSE\n", + "17 2025-06-02 17:24:00 SOL-USDT SELL OPEN 153.70 -2.748538 2.748538 -2.748538 ADA-USDT & SOL-USDT OPEN\n", + "19 2025-06-02 17:35:00 SOL-USDT BUY CLOSE 152.99 -0.413061 0.413061 -0.413061 ADA-USDT & SOL-USDT CLOSE\n", + "21 2025-06-02 18:02:00 SOL-USDT BUY OPEN 153.64 2.047229 2.047229 2.047229 ADA-USDT & SOL-USDT OPEN\n", + "23 2025-06-02 18:06:00 SOL-USDT SELL CLOSE 153.84 -0.089168 0.089168 -0.089168 ADA-USDT & SOL-USDT CLOSE\n", + "25 2025-06-02 19:35:00 SOL-USDT SELL OPEN 152.13 -2.016878 2.016878 -2.016878 ADA-USDT & SOL-USDT OPEN\n", + "27 2025-06-02 22:28:00 SOL-USDT BUY CLOSE 156.75 0.000000 0.000000 0.000000 ADA-USDT & SOL-USDT CLOSE_POSITION\n" ] }, { @@ -1869,6 +1882,126 @@ "opacity": 0.8, "type": "scatter", "x": [ + "2025-06-02T11:30:00.000000000", + "2025-06-02T11:31:00.000000000", + "2025-06-02T11:32:00.000000000", + "2025-06-02T11:33:00.000000000", + "2025-06-02T11:34:00.000000000", + "2025-06-02T11:35:00.000000000", + "2025-06-02T11:36:00.000000000", + "2025-06-02T11:37:00.000000000", + "2025-06-02T11:38:00.000000000", + "2025-06-02T11:39:00.000000000", + "2025-06-02T11:40:00.000000000", + "2025-06-02T11:41:00.000000000", + "2025-06-02T11:42:00.000000000", + "2025-06-02T11:43:00.000000000", + "2025-06-02T11:44:00.000000000", + "2025-06-02T11:45:00.000000000", + "2025-06-02T11:46:00.000000000", + "2025-06-02T11:47:00.000000000", + "2025-06-02T11:48:00.000000000", + "2025-06-02T11:49:00.000000000", + "2025-06-02T11:50:00.000000000", + "2025-06-02T11:51:00.000000000", + "2025-06-02T11:52:00.000000000", + "2025-06-02T11:53:00.000000000", + "2025-06-02T11:54:00.000000000", + "2025-06-02T11:55:00.000000000", + "2025-06-02T11:56:00.000000000", + "2025-06-02T11:57:00.000000000", + "2025-06-02T11:58:00.000000000", + "2025-06-02T11:59:00.000000000", + "2025-06-02T12:00:00.000000000", + "2025-06-02T12:01:00.000000000", + "2025-06-02T12:02:00.000000000", + "2025-06-02T12:03:00.000000000", + "2025-06-02T12:04:00.000000000", + "2025-06-02T12:05:00.000000000", + "2025-06-02T12:06:00.000000000", + "2025-06-02T12:07:00.000000000", + "2025-06-02T12:08:00.000000000", + "2025-06-02T12:09:00.000000000", + "2025-06-02T12:10:00.000000000", + "2025-06-02T12:11:00.000000000", + "2025-06-02T12:12:00.000000000", + "2025-06-02T12:13:00.000000000", + "2025-06-02T12:14:00.000000000", + "2025-06-02T12:15:00.000000000", + "2025-06-02T12:16:00.000000000", + "2025-06-02T12:17:00.000000000", + "2025-06-02T12:18:00.000000000", + "2025-06-02T12:19:00.000000000", + "2025-06-02T12:20:00.000000000", + "2025-06-02T12:21:00.000000000", + "2025-06-02T12:22:00.000000000", + "2025-06-02T12:23:00.000000000", + "2025-06-02T12:24:00.000000000", + "2025-06-02T12:25:00.000000000", + "2025-06-02T12:26:00.000000000", + "2025-06-02T12:27:00.000000000", + "2025-06-02T12:28:00.000000000", + "2025-06-02T12:29:00.000000000", + "2025-06-02T12:30:00.000000000", + "2025-06-02T12:31:00.000000000", + "2025-06-02T12:32:00.000000000", + "2025-06-02T12:33:00.000000000", + "2025-06-02T12:34:00.000000000", + "2025-06-02T12:35:00.000000000", + "2025-06-02T12:36:00.000000000", + "2025-06-02T12:37:00.000000000", + "2025-06-02T12:38:00.000000000", + "2025-06-02T12:39:00.000000000", + "2025-06-02T12:40:00.000000000", + "2025-06-02T12:41:00.000000000", + "2025-06-02T12:42:00.000000000", + "2025-06-02T12:43:00.000000000", + "2025-06-02T12:44:00.000000000", + "2025-06-02T12:45:00.000000000", + "2025-06-02T12:46:00.000000000", + "2025-06-02T12:47:00.000000000", + "2025-06-02T12:48:00.000000000", + "2025-06-02T12:49:00.000000000", + "2025-06-02T12:50:00.000000000", + "2025-06-02T12:51:00.000000000", + "2025-06-02T12:52:00.000000000", + "2025-06-02T12:53:00.000000000", + "2025-06-02T12:54:00.000000000", + "2025-06-02T12:55:00.000000000", + "2025-06-02T12:56:00.000000000", + "2025-06-02T12:57:00.000000000", + "2025-06-02T12:58:00.000000000", + "2025-06-02T12:59:00.000000000", + "2025-06-02T13:00:00.000000000", + "2025-06-02T13:01:00.000000000", + "2025-06-02T13:02:00.000000000", + "2025-06-02T13:03:00.000000000", + "2025-06-02T13:04:00.000000000", + "2025-06-02T13:05:00.000000000", + "2025-06-02T13:06:00.000000000", + "2025-06-02T13:07:00.000000000", + "2025-06-02T13:08:00.000000000", + "2025-06-02T13:09:00.000000000", + "2025-06-02T13:10:00.000000000", + "2025-06-02T13:11:00.000000000", + "2025-06-02T13:12:00.000000000", + "2025-06-02T13:13:00.000000000", + "2025-06-02T13:14:00.000000000", + "2025-06-02T13:15:00.000000000", + "2025-06-02T13:16:00.000000000", + "2025-06-02T13:17:00.000000000", + "2025-06-02T13:18:00.000000000", + "2025-06-02T13:19:00.000000000", + "2025-06-02T13:20:00.000000000", + "2025-06-02T13:21:00.000000000", + "2025-06-02T13:22:00.000000000", + "2025-06-02T13:23:00.000000000", + "2025-06-02T13:24:00.000000000", + "2025-06-02T13:25:00.000000000", + "2025-06-02T13:26:00.000000000", + "2025-06-02T13:27:00.000000000", + "2025-06-02T13:28:00.000000000", + "2025-06-02T13:29:00.000000000", "2025-06-02T13:30:00.000000000", "2025-06-02T13:31:00.000000000", "2025-06-02T13:32:00.000000000", @@ -2407,12 +2540,11 @@ "2025-06-02T22:26:00.000000000", "2025-06-02T22:27:00.000000000", "2025-06-02T22:28:00.000000000", - "2025-06-02T22:29:00.000000000", - "2025-06-02T22:30:00.000000000" + "2025-06-02T22:29:00.000000000" ], "xaxis": "x", "y": { - "bdata": "AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/HeIwLPsiB0D7ZI6+zL4GQAaixX4o+vg/hf6wLTje/j/KOlUbmWsAQHLTDR2zBPw/uATLujJF9j/P618gfKP2PyVdrQZw4uw/mSHqqkxI5z9xm/fT9PeNP6byz/FGAdQ/C1vwLHfY5D8TLAxij0TvPy7ZLx00b+I/sGKIWqoB8j9M7TqLGwzQP8kGos2fB9M/hK7iO+ka2T+2NNJiQeXuPxQTd/9uZNA/3byNxIJXrD8Iki2Hq4fVP0EBjTCymlE/aRx+z7VU2j+w79xITkLZP1k0U5zQhtY/wrKku5v8kD/lI+TIIxuyP9yCErE/ZYE/VYkgN+JO5z93mU6K3ArZPzT5PulqbNw/l+MyFJ7Z2T9R5rtJmbzeP7foE2F0vuo/Q/a24nY66T8LSiSwPxvaP1Y6ZBBVseU/U31DvB/21j/c+rGOScjrPxGIAWZ1c+s/P0aQAZkk4T8C9Er0sNvjP5oUDamnFPc/hW2jpq2G+j+l+7qkqv31P70BZ6/V9PY/OmAT8FcD9D9iLZnyWxPdP7r9NLHpkM8/up+masDU0j8jSLRV0EpiPwza73ybMZs/YVbpZP0Lxj9jJ7iCAWzYP29a4DCH7Oc/qHG57zQ9vz/sYIYDJEGuP3kXI6G2moQ/s9Ur82Orwz9rOdHTvgZjP2iE08u2vsI/VVyM6TFM0z8j550TRmK2P0SzK4KaMdc/qA4qpdMe5T9fXQMfflLoP9arayVuq/E/z5vrKGxy+T9lljDXzEjzP0F4jEqhmPk/6bOnER5B/T+Jv+r+EOsCQJVO4zuk6whABSa1ZpGYCEDtSq7M9U4QQGANCTYHFw9AgifssmsKEUCp/KxbDswOQLzF806S8QtAYgPn6qXYCkCHTq5FofYFQIDjJcY8zQNAl3tTyh/KB0BAXXf35xwDQBeq5/sbzQRACwIgUAGhA0DYKA8lAj/5P0KygQMRJvE/JJIGAJRD3T+thr80mcD0P5s6MjZTiu0/aG8DxAu69z8v0E6t/qD2P/vi0t83hwFAbxsgDflcAkCBL+d3qKwCQDBlPYWc0Po/vKp6SY3H/T8ZtAdUAhjhP43MBzuPyvg/1z/ag0tN9T/cLlZZHRDuPzJma7ZdW/Y/EfOAnyf28z860WUuJYXDP8yt07Dp99Y/Dp2ILiFd5z8YbtWVeO7yPxV2LBpJmPs/OYFUHHJx8D/8RJjKuKT3P3M8OpMB/QVAmvGy2nyP+z9WExKx5X/2P8SfwAMDqvo/FnrbtlRn+z8YhZs7PTr3P1WO3coVIvQ/DPPWlE/c+j/nn3pG6ZP5P/6W7QLwsfI/p0YxD7X14T/axuM4mW/aP+P/Eo+OMMQ/dtJSGo4lwj+dqVsucIXVPx3a4VDgfdY/uNOE8Vg14D+VG+6+JQG9P51hZ49VINQ/8uX5a0TOuD+A0KLtV1DgP5/6xnfeSec/eiWWQien2z+YjgGBQZ7tP3WFjUbxjfQ/I38ZsMfG6z9ynbEeXy75P1l4HkcvNPQ/5dgk0hQj8z+FbdiFWO3wPykhzwJoSvc/hLszsduu9j/qsnXtaZrxP/Axtrx7b+g/2zXqEpZH8j/PEjwYxDnyP3RfMeQtWPI/w3CF4f3k9z8AVjWKuWAAQEi90tCJgfY/nzAazOi44T+lYZhkomPjP40uR6O+07Y/HdubnYPk3D+mGUWJuXPZP+NUFyi/geU//203TiNv4D+4WKuE/iXvP8GQlIabjtw/HZjeQF996D/97JfHkUDlP+hmFtLp2e0/kQoQ6ONW5T80cn6nOPDvP4PQ75UVEvA/eVD8KVs04T8iI3ZJf+7gPxzwa4NsLuo/pzwZ6tCG3D8wCTN+cbDPP7Y8mrw1C9Q/CMzw8cOruj+pKeiJ0CzpP8gwl8JlINQ/BP88P3iWxT+BiXyfouvQP9U7nQvjRuE/t4wwxnHh4j/aHOU+XQTsPyt+TwnQqe8/f+bHQlb95T8etrS91inSP6AYpYhmMdU/GlMKiRAajz9YZ5oIYvrTP79uc2QBpcw/vDuSi8P21j+HrxA1JbbYPxOLTF2sQNM/sWtF1yLV0D+cUdZIelbdP+GuH8Knz8I/YVPgv0gE0j+nnwNwFS/hP3NomQntItQ/6D3JAYx3wj8LvjVD0v3VP+t7K1iSP90/pGVktwzLzj+5xoEr5X/dP1rtUEyp4+k//lvc4xMv1z+SNL2ie+vkP10w3LJfiu4/OZXP1f5G6D/01EP/dE3mP93+f7Sn1ec/3oap72uk8T9lnj2bi5D2PyUR43WwufI/yMPzAdi18j+DrJDo9Df1PwlII8mTMPI/FeUTLEEr7T8GmbFpMAzYP8ll5TLBw+U/67s3II7L8D8N01hdvwHmPy/tVysPfc0/sayJBiW21D9q4Pdz6s3UP2+FFAGni+E/ehZYdDOi1D/3FQIIRWvUP6iTpl20qdY/mNiF9k9i3D/E0+4pBK3gPzUqyrPgL9c/GgIqJ5go1D9TXBqhJ0rLP9AkCmx6uNg/pisNqd8z3j+4uvOumT3FP1yb46GT270/sMNqXrjTrD8pcA7D6ePGP2HuyxMuVOc/xbD+Ijj17j/PQALl1tzoP0IrYgrPYfg/jHz51bn89z9RhIWwkCIAQJgzAOieEP0/AJqpjHF9+j9LUYMhimX5Pw1H0ml04/g/1qxDMU8SAUDSsOCVmHYBQLsC8FaFoQJACKnOHr6SA0AGliUUaG4AQNKQC2OjlQFAFwLm2ToQAEDpnmttiTsAQI88sPAmJgFAxgH0AiSt+z8ckTbf7kL7P+t/NS3PEvw/ulXPcZ6Y/T+zImkorzD3P5/H2U5zpfs/H0WYvLfT+z9uXREKwPr4PwSXzFE5z/M/ULTRznEC9z8t9dZdRGH0P1MLoIn/CfM/46INfJsC8j+9DOyiZ/zyP/d18C5M/fE/x+X+Hqbx6j/NAHppx6DsPx2542HrwfI/2eu+3YoP8z/lcQnuhxvxP6Lt/FW46fE/U4RN36ym9j9eMMMi4C/5P5UXTUG7ifo/NelTEWNn+j/jTYd7a9z2P5FJoFaQCPQ/bkSGqhgj8j+h6dFeWejtP2f44IytQOk//ohLfouI5z9CebPdWo7pP7VNlwsuzOs/syFcPEmW4z/rAkl685DvP3i5zz0lI/A/xehx3/R98D9+XHZcVDvwP3ztbJDJ+fM/equhmQUa9j8I8OI9Zx34PyzHEX3Eh/s/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/AAAAAAAA+H8AAAAAAAD4fwAAAAAAAPh/", + "bdata": "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", "dtype": "f8" }, "yaxis": "y" @@ -2426,6 +2558,126 @@ "opacity": 0.8, "type": "scatter", "x": [ + "2025-06-02T11:30:00.000000000", + "2025-06-02T11:31:00.000000000", + "2025-06-02T11:32:00.000000000", + "2025-06-02T11:33:00.000000000", + "2025-06-02T11:34:00.000000000", + "2025-06-02T11:35:00.000000000", + "2025-06-02T11:36:00.000000000", + "2025-06-02T11:37:00.000000000", + "2025-06-02T11:38:00.000000000", + "2025-06-02T11:39:00.000000000", + "2025-06-02T11:40:00.000000000", + "2025-06-02T11:41:00.000000000", + "2025-06-02T11:42:00.000000000", + "2025-06-02T11:43:00.000000000", + "2025-06-02T11:44:00.000000000", + "2025-06-02T11:45:00.000000000", + "2025-06-02T11:46:00.000000000", + "2025-06-02T11:47:00.000000000", + "2025-06-02T11:48:00.000000000", + "2025-06-02T11:49:00.000000000", + "2025-06-02T11:50:00.000000000", + "2025-06-02T11:51:00.000000000", + "2025-06-02T11:52:00.000000000", + "2025-06-02T11:53:00.000000000", + "2025-06-02T11:54:00.000000000", + "2025-06-02T11:55:00.000000000", + "2025-06-02T11:56:00.000000000", + "2025-06-02T11:57:00.000000000", + "2025-06-02T11:58:00.000000000", + "2025-06-02T11:59:00.000000000", + "2025-06-02T12:00:00.000000000", + "2025-06-02T12:01:00.000000000", + "2025-06-02T12:02:00.000000000", + "2025-06-02T12:03:00.000000000", + "2025-06-02T12:04:00.000000000", + "2025-06-02T12:05:00.000000000", + "2025-06-02T12:06:00.000000000", + "2025-06-02T12:07:00.000000000", + "2025-06-02T12:08:00.000000000", + "2025-06-02T12:09:00.000000000", + "2025-06-02T12:10:00.000000000", + "2025-06-02T12:11:00.000000000", + "2025-06-02T12:12:00.000000000", + "2025-06-02T12:13:00.000000000", + "2025-06-02T12:14:00.000000000", + "2025-06-02T12:15:00.000000000", + "2025-06-02T12:16:00.000000000", + "2025-06-02T12:17:00.000000000", + "2025-06-02T12:18:00.000000000", + "2025-06-02T12:19:00.000000000", + "2025-06-02T12:20:00.000000000", + "2025-06-02T12:21:00.000000000", + "2025-06-02T12:22:00.000000000", + "2025-06-02T12:23:00.000000000", + "2025-06-02T12:24:00.000000000", + "2025-06-02T12:25:00.000000000", + "2025-06-02T12:26:00.000000000", + "2025-06-02T12:27:00.000000000", + "2025-06-02T12:28:00.000000000", + "2025-06-02T12:29:00.000000000", + "2025-06-02T12:30:00.000000000", + "2025-06-02T12:31:00.000000000", + "2025-06-02T12:32:00.000000000", + "2025-06-02T12:33:00.000000000", + "2025-06-02T12:34:00.000000000", + "2025-06-02T12:35:00.000000000", + "2025-06-02T12:36:00.000000000", + "2025-06-02T12:37:00.000000000", + "2025-06-02T12:38:00.000000000", + "2025-06-02T12:39:00.000000000", + "2025-06-02T12:40:00.000000000", + "2025-06-02T12:41:00.000000000", + "2025-06-02T12:42:00.000000000", + "2025-06-02T12:43:00.000000000", + "2025-06-02T12:44:00.000000000", + "2025-06-02T12:45:00.000000000", + "2025-06-02T12:46:00.000000000", + "2025-06-02T12:47:00.000000000", + "2025-06-02T12:48:00.000000000", + "2025-06-02T12:49:00.000000000", + "2025-06-02T12:50:00.000000000", + "2025-06-02T12:51:00.000000000", + "2025-06-02T12:52:00.000000000", + "2025-06-02T12:53:00.000000000", + "2025-06-02T12:54:00.000000000", + "2025-06-02T12:55:00.000000000", + "2025-06-02T12:56:00.000000000", + "2025-06-02T12:57:00.000000000", + "2025-06-02T12:58:00.000000000", + "2025-06-02T12:59:00.000000000", + "2025-06-02T13:00:00.000000000", + "2025-06-02T13:01:00.000000000", + "2025-06-02T13:02:00.000000000", + "2025-06-02T13:03:00.000000000", + "2025-06-02T13:04:00.000000000", + "2025-06-02T13:05:00.000000000", + "2025-06-02T13:06:00.000000000", + "2025-06-02T13:07:00.000000000", + "2025-06-02T13:08:00.000000000", + "2025-06-02T13:09:00.000000000", + "2025-06-02T13:10:00.000000000", + "2025-06-02T13:11:00.000000000", + "2025-06-02T13:12:00.000000000", + "2025-06-02T13:13:00.000000000", + "2025-06-02T13:14:00.000000000", + "2025-06-02T13:15:00.000000000", + "2025-06-02T13:16:00.000000000", + "2025-06-02T13:17:00.000000000", + "2025-06-02T13:18:00.000000000", + "2025-06-02T13:19:00.000000000", + "2025-06-02T13:20:00.000000000", + "2025-06-02T13:21:00.000000000", + "2025-06-02T13:22:00.000000000", + "2025-06-02T13:23:00.000000000", + "2025-06-02T13:24:00.000000000", + "2025-06-02T13:25:00.000000000", + "2025-06-02T13:26:00.000000000", + "2025-06-02T13:27:00.000000000", + "2025-06-02T13:28:00.000000000", + "2025-06-02T13:29:00.000000000", "2025-06-02T13:30:00.000000000", "2025-06-02T13:31:00.000000000", "2025-06-02T13:32:00.000000000", @@ -2964,12 +3216,11 @@ "2025-06-02T22:26:00.000000000", "2025-06-02T22:27:00.000000000", "2025-06-02T22:28:00.000000000", - "2025-06-02T22:29:00.000000000", - "2025-06-02T22:30:00.000000000" + "2025-06-02T22:29:00.000000000" ], "xaxis": "x", "y": { - "bdata": "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", + "bdata": "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", "dtype": "f8" }, "yaxis": "y" @@ -2983,6 +3234,126 @@ "opacity": 0.8, "type": "scatter", "x": [ + "2025-06-02T11:30:00.000000000", + "2025-06-02T11:31:00.000000000", + "2025-06-02T11:32:00.000000000", + "2025-06-02T11:33:00.000000000", + "2025-06-02T11:34:00.000000000", + "2025-06-02T11:35:00.000000000", + "2025-06-02T11:36:00.000000000", + "2025-06-02T11:37:00.000000000", + "2025-06-02T11:38:00.000000000", + "2025-06-02T11:39:00.000000000", + "2025-06-02T11:40:00.000000000", + "2025-06-02T11:41:00.000000000", + "2025-06-02T11:42:00.000000000", + "2025-06-02T11:43:00.000000000", + "2025-06-02T11:44:00.000000000", + "2025-06-02T11:45:00.000000000", + "2025-06-02T11:46:00.000000000", + "2025-06-02T11:47:00.000000000", + "2025-06-02T11:48:00.000000000", + "2025-06-02T11:49:00.000000000", + "2025-06-02T11:50:00.000000000", + "2025-06-02T11:51:00.000000000", + "2025-06-02T11:52:00.000000000", + "2025-06-02T11:53:00.000000000", + "2025-06-02T11:54:00.000000000", + "2025-06-02T11:55:00.000000000", + "2025-06-02T11:56:00.000000000", + "2025-06-02T11:57:00.000000000", + "2025-06-02T11:58:00.000000000", + "2025-06-02T11:59:00.000000000", + "2025-06-02T12:00:00.000000000", + "2025-06-02T12:01:00.000000000", + "2025-06-02T12:02:00.000000000", + "2025-06-02T12:03:00.000000000", + "2025-06-02T12:04:00.000000000", + "2025-06-02T12:05:00.000000000", + "2025-06-02T12:06:00.000000000", + "2025-06-02T12:07:00.000000000", + "2025-06-02T12:08:00.000000000", + "2025-06-02T12:09:00.000000000", + "2025-06-02T12:10:00.000000000", + "2025-06-02T12:11:00.000000000", + "2025-06-02T12:12:00.000000000", + "2025-06-02T12:13:00.000000000", + "2025-06-02T12:14:00.000000000", + "2025-06-02T12:15:00.000000000", + "2025-06-02T12:16:00.000000000", + "2025-06-02T12:17:00.000000000", + "2025-06-02T12:18:00.000000000", + "2025-06-02T12:19:00.000000000", + "2025-06-02T12:20:00.000000000", + "2025-06-02T12:21:00.000000000", + "2025-06-02T12:22:00.000000000", + "2025-06-02T12:23:00.000000000", + "2025-06-02T12:24:00.000000000", + "2025-06-02T12:25:00.000000000", + "2025-06-02T12:26:00.000000000", + "2025-06-02T12:27:00.000000000", + "2025-06-02T12:28:00.000000000", + "2025-06-02T12:29:00.000000000", + "2025-06-02T12:30:00.000000000", + "2025-06-02T12:31:00.000000000", + "2025-06-02T12:32:00.000000000", + "2025-06-02T12:33:00.000000000", + "2025-06-02T12:34:00.000000000", + "2025-06-02T12:35:00.000000000", + "2025-06-02T12:36:00.000000000", + "2025-06-02T12:37:00.000000000", + "2025-06-02T12:38:00.000000000", + "2025-06-02T12:39:00.000000000", + "2025-06-02T12:40:00.000000000", + "2025-06-02T12:41:00.000000000", + "2025-06-02T12:42:00.000000000", + "2025-06-02T12:43:00.000000000", + "2025-06-02T12:44:00.000000000", + "2025-06-02T12:45:00.000000000", + "2025-06-02T12:46:00.000000000", + "2025-06-02T12:47:00.000000000", + "2025-06-02T12:48:00.000000000", + "2025-06-02T12:49:00.000000000", + "2025-06-02T12:50:00.000000000", + "2025-06-02T12:51:00.000000000", + "2025-06-02T12:52:00.000000000", + "2025-06-02T12:53:00.000000000", + "2025-06-02T12:54:00.000000000", + "2025-06-02T12:55:00.000000000", + "2025-06-02T12:56:00.000000000", + "2025-06-02T12:57:00.000000000", + "2025-06-02T12:58:00.000000000", + "2025-06-02T12:59:00.000000000", + "2025-06-02T13:00:00.000000000", + "2025-06-02T13:01:00.000000000", + "2025-06-02T13:02:00.000000000", + "2025-06-02T13:03:00.000000000", + "2025-06-02T13:04:00.000000000", + "2025-06-02T13:05:00.000000000", + "2025-06-02T13:06:00.000000000", + "2025-06-02T13:07:00.000000000", + "2025-06-02T13:08:00.000000000", + "2025-06-02T13:09:00.000000000", + "2025-06-02T13:10:00.000000000", + "2025-06-02T13:11:00.000000000", + "2025-06-02T13:12:00.000000000", + "2025-06-02T13:13:00.000000000", + "2025-06-02T13:14:00.000000000", + "2025-06-02T13:15:00.000000000", + "2025-06-02T13:16:00.000000000", + "2025-06-02T13:17:00.000000000", + "2025-06-02T13:18:00.000000000", + "2025-06-02T13:19:00.000000000", + "2025-06-02T13:20:00.000000000", + "2025-06-02T13:21:00.000000000", + "2025-06-02T13:22:00.000000000", + "2025-06-02T13:23:00.000000000", + "2025-06-02T13:24:00.000000000", + "2025-06-02T13:25:00.000000000", + "2025-06-02T13:26:00.000000000", + "2025-06-02T13:27:00.000000000", + "2025-06-02T13:28:00.000000000", + "2025-06-02T13:29:00.000000000", "2025-06-02T13:30:00.000000000", "2025-06-02T13:31:00.000000000", "2025-06-02T13:32:00.000000000", @@ -3521,12 +3892,11 @@ "2025-06-02T22:26:00.000000000", "2025-06-02T22:27:00.000000000", "2025-06-02T22:28:00.000000000", - "2025-06-02T22:29:00.000000000", - "2025-06-02T22:30:00.000000000" + "2025-06-02T22:29:00.000000000" ], "xaxis": "x2", "y": { - "bdata": "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", + "bdata": "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", "dtype": "f8" }, "yaxis": "y2" @@ -3540,6 +3910,126 @@ "opacity": 0.8, "type": "scatter", "x": [ + "2025-06-02T11:30:00.000000000", + "2025-06-02T11:31:00.000000000", + "2025-06-02T11:32:00.000000000", + "2025-06-02T11:33:00.000000000", + "2025-06-02T11:34:00.000000000", + "2025-06-02T11:35:00.000000000", + "2025-06-02T11:36:00.000000000", + "2025-06-02T11:37:00.000000000", + "2025-06-02T11:38:00.000000000", + "2025-06-02T11:39:00.000000000", + "2025-06-02T11:40:00.000000000", + "2025-06-02T11:41:00.000000000", + "2025-06-02T11:42:00.000000000", + "2025-06-02T11:43:00.000000000", + "2025-06-02T11:44:00.000000000", + "2025-06-02T11:45:00.000000000", + "2025-06-02T11:46:00.000000000", + "2025-06-02T11:47:00.000000000", + "2025-06-02T11:48:00.000000000", + "2025-06-02T11:49:00.000000000", + "2025-06-02T11:50:00.000000000", + "2025-06-02T11:51:00.000000000", + "2025-06-02T11:52:00.000000000", + "2025-06-02T11:53:00.000000000", + "2025-06-02T11:54:00.000000000", + "2025-06-02T11:55:00.000000000", + "2025-06-02T11:56:00.000000000", + "2025-06-02T11:57:00.000000000", + "2025-06-02T11:58:00.000000000", + "2025-06-02T11:59:00.000000000", + "2025-06-02T12:00:00.000000000", + "2025-06-02T12:01:00.000000000", + "2025-06-02T12:02:00.000000000", + "2025-06-02T12:03:00.000000000", + "2025-06-02T12:04:00.000000000", + "2025-06-02T12:05:00.000000000", + "2025-06-02T12:06:00.000000000", + "2025-06-02T12:07:00.000000000", + "2025-06-02T12:08:00.000000000", + "2025-06-02T12:09:00.000000000", + "2025-06-02T12:10:00.000000000", + "2025-06-02T12:11:00.000000000", + "2025-06-02T12:12:00.000000000", + "2025-06-02T12:13:00.000000000", + "2025-06-02T12:14:00.000000000", + "2025-06-02T12:15:00.000000000", + "2025-06-02T12:16:00.000000000", + "2025-06-02T12:17:00.000000000", + "2025-06-02T12:18:00.000000000", + "2025-06-02T12:19:00.000000000", + "2025-06-02T12:20:00.000000000", + "2025-06-02T12:21:00.000000000", + "2025-06-02T12:22:00.000000000", + "2025-06-02T12:23:00.000000000", + "2025-06-02T12:24:00.000000000", + "2025-06-02T12:25:00.000000000", + "2025-06-02T12:26:00.000000000", + "2025-06-02T12:27:00.000000000", + "2025-06-02T12:28:00.000000000", + "2025-06-02T12:29:00.000000000", + "2025-06-02T12:30:00.000000000", + "2025-06-02T12:31:00.000000000", + "2025-06-02T12:32:00.000000000", + "2025-06-02T12:33:00.000000000", + "2025-06-02T12:34:00.000000000", + "2025-06-02T12:35:00.000000000", + "2025-06-02T12:36:00.000000000", + "2025-06-02T12:37:00.000000000", + "2025-06-02T12:38:00.000000000", + "2025-06-02T12:39:00.000000000", + "2025-06-02T12:40:00.000000000", + "2025-06-02T12:41:00.000000000", + "2025-06-02T12:42:00.000000000", + "2025-06-02T12:43:00.000000000", + "2025-06-02T12:44:00.000000000", + "2025-06-02T12:45:00.000000000", + "2025-06-02T12:46:00.000000000", + "2025-06-02T12:47:00.000000000", + "2025-06-02T12:48:00.000000000", + "2025-06-02T12:49:00.000000000", + "2025-06-02T12:50:00.000000000", + "2025-06-02T12:51:00.000000000", + "2025-06-02T12:52:00.000000000", + "2025-06-02T12:53:00.000000000", + "2025-06-02T12:54:00.000000000", + "2025-06-02T12:55:00.000000000", + "2025-06-02T12:56:00.000000000", + "2025-06-02T12:57:00.000000000", + "2025-06-02T12:58:00.000000000", + "2025-06-02T12:59:00.000000000", + "2025-06-02T13:00:00.000000000", + "2025-06-02T13:01:00.000000000", + "2025-06-02T13:02:00.000000000", + "2025-06-02T13:03:00.000000000", + "2025-06-02T13:04:00.000000000", + "2025-06-02T13:05:00.000000000", + "2025-06-02T13:06:00.000000000", + "2025-06-02T13:07:00.000000000", + "2025-06-02T13:08:00.000000000", + "2025-06-02T13:09:00.000000000", + "2025-06-02T13:10:00.000000000", + "2025-06-02T13:11:00.000000000", + "2025-06-02T13:12:00.000000000", + "2025-06-02T13:13:00.000000000", + "2025-06-02T13:14:00.000000000", + "2025-06-02T13:15:00.000000000", + "2025-06-02T13:16:00.000000000", + "2025-06-02T13:17:00.000000000", + "2025-06-02T13:18:00.000000000", + "2025-06-02T13:19:00.000000000", + "2025-06-02T13:20:00.000000000", + "2025-06-02T13:21:00.000000000", + "2025-06-02T13:22:00.000000000", + "2025-06-02T13:23:00.000000000", + "2025-06-02T13:24:00.000000000", + "2025-06-02T13:25:00.000000000", + "2025-06-02T13:26:00.000000000", + "2025-06-02T13:27:00.000000000", + "2025-06-02T13:28:00.000000000", + "2025-06-02T13:29:00.000000000", "2025-06-02T13:30:00.000000000", "2025-06-02T13:31:00.000000000", "2025-06-02T13:32:00.000000000", @@ -4078,12 +4568,11 @@ "2025-06-02T22:26:00.000000000", "2025-06-02T22:27:00.000000000", "2025-06-02T22:28:00.000000000", - "2025-06-02T22:29:00.000000000", - "2025-06-02T22:30:00.000000000" + "2025-06-02T22:29:00.000000000" ], "xaxis": "x2", "y": { - "bdata": "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", + "bdata": "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", "dtype": "f8" }, "yaxis": "y2" @@ -4099,15 +4588,17 @@ "name": "ADA-USDT BUY OPEN", "showlegend": true, "text": [ - "ADA-USDT BUY OPEN OPEN
Time: 2025-06-02 15:31:00
Normalized Price: 1.0036
Actual Price: $0.67", - "ADA-USDT BUY OPEN OPEN
Time: 2025-06-02 16:44:00
Normalized Price: 0.9999
Actual Price: $0.67", - "ADA-USDT BUY OPEN OPEN
Time: 2025-06-02 17:06:00
Normalized Price: 1.0043
Actual Price: $0.67", - "ADA-USDT BUY OPEN OPEN
Time: 2025-06-02 17:24:00
Normalized Price: 1.0069
Actual Price: $0.68", - "ADA-USDT BUY OPEN OPEN
Time: 2025-06-02 19:35:00
Normalized Price: 1.0015
Actual Price: $0.67" + "ADA-USDT BUY OPEN OPEN
Time: 2025-06-02 13:37:00
Normalized Price: 1.0109
Actual Price: $0.68", + "ADA-USDT BUY OPEN OPEN
Time: 2025-06-02 15:09:00
Normalized Price: 1.0028
Actual Price: $0.67", + "ADA-USDT BUY OPEN OPEN
Time: 2025-06-02 16:44:00
Normalized Price: 1.0057
Actual Price: $0.67", + "ADA-USDT BUY OPEN OPEN
Time: 2025-06-02 17:06:00
Normalized Price: 1.0102
Actual Price: $0.67", + "ADA-USDT BUY OPEN OPEN
Time: 2025-06-02 17:24:00
Normalized Price: 1.0127
Actual Price: $0.68", + "ADA-USDT BUY OPEN OPEN
Time: 2025-06-02 19:35:00
Normalized Price: 1.0073
Actual Price: $0.67" ], "type": "scatter", "x": [ - "2025-06-02T15:31:00", + "2025-06-02T13:37:00", + "2025-06-02T15:09:00", "2025-06-02T16:44:00", "2025-06-02T17:06:00", "2025-06-02T17:24:00", @@ -4115,11 +4606,12 @@ ], "xaxis": "x2", "y": [ - 1.0035772842450439, - 0.9998509464897897, - 1.0043225517960948, - 1.0068564614696676, - 1.0014905351021017 + 1.010944527736132, + 1.002848575712144, + 1.0056971514242878, + 1.0101949025487256, + 1.012743628185907, + 1.0073463268365817 ], "yaxis": "y2" }, @@ -4134,15 +4626,17 @@ "name": "SOL-USDT SELL OPEN", "showlegend": true, "text": [ - "SOL-USDT SELL OPEN OPEN
Time: 2025-06-02 15:31:00
Normalized Price: 0.9966
Actual Price: $153.24", - "SOL-USDT SELL OPEN OPEN
Time: 2025-06-02 16:44:00
Normalized Price: 0.9921
Actual Price: $152.51", - "SOL-USDT SELL OPEN OPEN
Time: 2025-06-02 17:06:00
Normalized Price: 0.9949
Actual Price: $153.03", - "SOL-USDT SELL OPEN OPEN
Time: 2025-06-02 17:24:00
Normalized Price: 0.9992
Actual Price: $153.70", - "SOL-USDT SELL OPEN OPEN
Time: 2025-06-02 19:35:00
Normalized Price: 0.9890
Actual Price: $152.13" + "SOL-USDT SELL OPEN OPEN
Time: 2025-06-02 13:37:00
Normalized Price: 1.0008
Actual Price: $154.32", + "SOL-USDT SELL OPEN OPEN
Time: 2025-06-02 15:09:00
Normalized Price: 0.9877
Actual Price: $152.18", + "SOL-USDT SELL OPEN OPEN
Time: 2025-06-02 16:44:00
Normalized Price: 0.9900
Actual Price: $152.51", + "SOL-USDT SELL OPEN OPEN
Time: 2025-06-02 17:06:00
Normalized Price: 0.9928
Actual Price: $153.03", + "SOL-USDT SELL OPEN OPEN
Time: 2025-06-02 17:24:00
Normalized Price: 0.9971
Actual Price: $153.70", + "SOL-USDT SELL OPEN OPEN
Time: 2025-06-02 19:35:00
Normalized Price: 0.9869
Actual Price: $152.13" ], "type": "scatter", "x": [ - "2025-06-02T15:31:00", + "2025-06-02T13:37:00", + "2025-06-02T15:09:00", "2025-06-02T16:44:00", "2025-06-02T17:06:00", "2025-06-02T17:24:00", @@ -4150,11 +4644,12 @@ ], "xaxis": "x2", "y": [ - 0.9966163456533055, - 0.9921264966163456, - 0.9949245184799583, - 0.9992191566892243, - 0.9890031233732431 + 1.0008441010324005, + 0.9877280696058698, + 0.9900006493084865, + 0.9927926758002728, + 0.9970781118109214, + 0.9868839685734694 ], "yaxis": "y2" }, @@ -4173,27 +4668,30 @@ "name": "ADA-USDT SELL CLOSE", "showlegend": true, "text": [ - "ADA-USDT SELL CLOSE CLOSE
Time: 2025-06-02 15:41:00
Normalized Price: 1.0039
Actual Price: $0.67", - "ADA-USDT SELL CLOSE CLOSE
Time: 2025-06-02 17:01:00
Normalized Price: 1.0054
Actual Price: $0.67", - "ADA-USDT SELL CLOSE CLOSE
Time: 2025-06-02 17:17:00
Normalized Price: 1.0025
Actual Price: $0.67", - "ADA-USDT SELL CLOSE CLOSE
Time: 2025-06-02 17:35:00
Normalized Price: 1.0004
Actual Price: $0.67", - "ADA-USDT SELL CLOSE CLOSE
Time: 2025-06-02 22:29:00
Normalized Price: 1.0300
Actual Price: $0.69" + "ADA-USDT SELL CLOSE CLOSE
Time: 2025-06-02 14:37:00
Normalized Price: 1.0114
Actual Price: $0.67", + "ADA-USDT SELL CLOSE CLOSE
Time: 2025-06-02 15:41:00
Normalized Price: 1.0097
Actual Price: $0.67", + "ADA-USDT SELL CLOSE CLOSE
Time: 2025-06-02 17:01:00
Normalized Price: 1.0112
Actual Price: $0.67", + "ADA-USDT SELL CLOSE CLOSE
Time: 2025-06-02 17:17:00
Normalized Price: 1.0084
Actual Price: $0.67", + "ADA-USDT SELL CLOSE CLOSE
Time: 2025-06-02 17:35:00
Normalized Price: 1.0063
Actual Price: $0.67", + "ADA-USDT SELL CLOSE CLOSE
Time: 2025-06-02 22:28:00
Normalized Price: 1.0357
Actual Price: $0.69" ], "type": "scatter", "x": [ + "2025-06-02T14:37:00", "2025-06-02T15:41:00", "2025-06-02T17:01:00", "2025-06-02T17:17:00", "2025-06-02T17:35:00", - "2025-06-02T22:29:00" + "2025-06-02T22:28:00" ], "xaxis": "x2", "y": [ - 1.003875391265464, - 1.0053659263675658, - 1.0025339096735728, - 1.0004471605306304, - 1.029959755552243 + 1.0113943028485757, + 1.0097451274362819, + 1.0112443778110944, + 1.0083958020989505, + 1.0062968515742128, + 1.0356821589205396 ], "yaxis": "y2" }, @@ -4212,27 +4710,30 @@ "name": "SOL-USDT BUY CLOSE", "showlegend": true, "text": [ - "SOL-USDT BUY CLOSE CLOSE
Time: 2025-06-02 15:41:00
Normalized Price: 0.9961
Actual Price: $153.10", - "SOL-USDT BUY CLOSE CLOSE
Time: 2025-06-02 17:01:00
Normalized Price: 0.9969
Actual Price: $153.07", - "SOL-USDT BUY CLOSE CLOSE
Time: 2025-06-02 17:17:00
Normalized Price: 0.9941
Actual Price: $153.09", - "SOL-USDT BUY CLOSE CLOSE
Time: 2025-06-02 17:35:00
Normalized Price: 0.9958
Actual Price: $152.99", - "SOL-USDT BUY CLOSE CLOSE
Time: 2025-06-02 22:29:00
Normalized Price: 1.0200
Actual Price: $156.70" + "SOL-USDT BUY CLOSE CLOSE
Time: 2025-06-02 14:37:00
Normalized Price: 0.9999
Actual Price: $153.70", + "SOL-USDT BUY CLOSE CLOSE
Time: 2025-06-02 15:41:00
Normalized Price: 0.9940
Actual Price: $153.10", + "SOL-USDT BUY CLOSE CLOSE
Time: 2025-06-02 17:01:00
Normalized Price: 0.9948
Actual Price: $153.07", + "SOL-USDT BUY CLOSE CLOSE
Time: 2025-06-02 17:17:00
Normalized Price: 0.9920
Actual Price: $153.09", + "SOL-USDT BUY CLOSE CLOSE
Time: 2025-06-02 17:35:00
Normalized Price: 0.9936
Actual Price: $152.99", + "SOL-USDT BUY CLOSE CLOSE
Time: 2025-06-02 22:28:00
Normalized Price: 1.0171
Actual Price: $156.75" ], "type": "scatter", "x": [ + "2025-06-02T14:37:00", "2025-06-02T15:41:00", "2025-06-02T17:01:00", "2025-06-02T17:17:00", "2025-06-02T17:35:00", - "2025-06-02T22:29:00" + "2025-06-02T22:28:00" ], "xaxis": "x2", "y": [ - 0.9960957834461218, - 0.9969416970327954, - 0.9941436751691827, - 0.995770432066632, - 1.0199765747006766 + 0.9999350691513539, + 0.9939614310759043, + 0.9948055321083048, + 0.9920135056165185, + 0.9936367768326733, + 1.0171417440425947 ], "yaxis": "y2" }, @@ -4247,7 +4748,7 @@ "name": "ADA-USDT SELL OPEN", "showlegend": true, "text": [ - "ADA-USDT SELL OPEN OPEN
Time: 2025-06-02 18:02:00
Normalized Price: 1.0048
Actual Price: $0.67" + "ADA-USDT SELL OPEN OPEN
Time: 2025-06-02 18:02:00
Normalized Price: 1.0106
Actual Price: $0.67" ], "type": "scatter", "x": [ @@ -4255,7 +4756,7 @@ ], "xaxis": "x2", "y": [ - 1.0047697123267252 + 1.0106446776611695 ], "yaxis": "y2" }, @@ -4270,7 +4771,7 @@ "name": "SOL-USDT BUY OPEN", "showlegend": true, "text": [ - "SOL-USDT BUY OPEN OPEN
Time: 2025-06-02 18:02:00
Normalized Price: 0.9994
Actual Price: $153.64" + "SOL-USDT BUY OPEN OPEN
Time: 2025-06-02 18:02:00
Normalized Price: 0.9973
Actual Price: $153.64" ], "type": "scatter", "x": [ @@ -4278,7 +4779,7 @@ ], "xaxis": "x2", "y": [ - 0.9994143675169183 + 0.99727290435686 ], "yaxis": "y2" }, @@ -4297,7 +4798,7 @@ "name": "ADA-USDT BUY CLOSE", "showlegend": true, "text": [ - "ADA-USDT BUY CLOSE CLOSE
Time: 2025-06-02 18:06:00
Normalized Price: 1.0055
Actual Price: $0.67" + "ADA-USDT BUY CLOSE CLOSE
Time: 2025-06-02 18:06:00
Normalized Price: 1.0114
Actual Price: $0.67" ], "type": "scatter", "x": [ @@ -4305,7 +4806,7 @@ ], "xaxis": "x2", "y": [ - 1.005514979877776 + 1.0113943028485757 ], "yaxis": "y2" }, @@ -4324,7 +4825,7 @@ "name": "SOL-USDT SELL CLOSE", "showlegend": true, "text": [ - "SOL-USDT SELL CLOSE CLOSE
Time: 2025-06-02 18:06:00
Normalized Price: 1.0007
Actual Price: $153.84" + "SOL-USDT SELL CLOSE CLOSE
Time: 2025-06-02 18:06:00
Normalized Price: 0.9986
Actual Price: $153.84" ], "type": "scatter", "x": [ @@ -4332,7 +4833,7 @@ ], "xaxis": "x2", "y": [ - 1.0007157730348775 + 0.9985715213297838 ], "yaxis": "y2" }, @@ -4345,6 +4846,126 @@ "opacity": 0.8, "type": "scatter", "x": [ + "2025-06-02T11:30:00.000000000", + "2025-06-02T11:31:00.000000000", + "2025-06-02T11:32:00.000000000", + "2025-06-02T11:33:00.000000000", + "2025-06-02T11:34:00.000000000", + "2025-06-02T11:35:00.000000000", + "2025-06-02T11:36:00.000000000", + "2025-06-02T11:37:00.000000000", + "2025-06-02T11:38:00.000000000", + "2025-06-02T11:39:00.000000000", + "2025-06-02T11:40:00.000000000", + "2025-06-02T11:41:00.000000000", + "2025-06-02T11:42:00.000000000", + "2025-06-02T11:43:00.000000000", + "2025-06-02T11:44:00.000000000", + "2025-06-02T11:45:00.000000000", + "2025-06-02T11:46:00.000000000", + "2025-06-02T11:47:00.000000000", + "2025-06-02T11:48:00.000000000", + "2025-06-02T11:49:00.000000000", + "2025-06-02T11:50:00.000000000", + "2025-06-02T11:51:00.000000000", + "2025-06-02T11:52:00.000000000", + "2025-06-02T11:53:00.000000000", + "2025-06-02T11:54:00.000000000", + "2025-06-02T11:55:00.000000000", + "2025-06-02T11:56:00.000000000", + "2025-06-02T11:57:00.000000000", + "2025-06-02T11:58:00.000000000", + "2025-06-02T11:59:00.000000000", + "2025-06-02T12:00:00.000000000", + "2025-06-02T12:01:00.000000000", + "2025-06-02T12:02:00.000000000", + "2025-06-02T12:03:00.000000000", + "2025-06-02T12:04:00.000000000", + "2025-06-02T12:05:00.000000000", + "2025-06-02T12:06:00.000000000", + "2025-06-02T12:07:00.000000000", + "2025-06-02T12:08:00.000000000", + "2025-06-02T12:09:00.000000000", + "2025-06-02T12:10:00.000000000", + "2025-06-02T12:11:00.000000000", + "2025-06-02T12:12:00.000000000", + "2025-06-02T12:13:00.000000000", + "2025-06-02T12:14:00.000000000", + "2025-06-02T12:15:00.000000000", + "2025-06-02T12:16:00.000000000", + "2025-06-02T12:17:00.000000000", + "2025-06-02T12:18:00.000000000", + "2025-06-02T12:19:00.000000000", + "2025-06-02T12:20:00.000000000", + "2025-06-02T12:21:00.000000000", + "2025-06-02T12:22:00.000000000", + "2025-06-02T12:23:00.000000000", + "2025-06-02T12:24:00.000000000", + "2025-06-02T12:25:00.000000000", + "2025-06-02T12:26:00.000000000", + "2025-06-02T12:27:00.000000000", + "2025-06-02T12:28:00.000000000", + "2025-06-02T12:29:00.000000000", + "2025-06-02T12:30:00.000000000", + "2025-06-02T12:31:00.000000000", + "2025-06-02T12:32:00.000000000", + "2025-06-02T12:33:00.000000000", + "2025-06-02T12:34:00.000000000", + "2025-06-02T12:35:00.000000000", + "2025-06-02T12:36:00.000000000", + "2025-06-02T12:37:00.000000000", + "2025-06-02T12:38:00.000000000", + "2025-06-02T12:39:00.000000000", + "2025-06-02T12:40:00.000000000", + "2025-06-02T12:41:00.000000000", + "2025-06-02T12:42:00.000000000", + "2025-06-02T12:43:00.000000000", + "2025-06-02T12:44:00.000000000", + "2025-06-02T12:45:00.000000000", + "2025-06-02T12:46:00.000000000", + "2025-06-02T12:47:00.000000000", + "2025-06-02T12:48:00.000000000", + "2025-06-02T12:49:00.000000000", + "2025-06-02T12:50:00.000000000", + "2025-06-02T12:51:00.000000000", + "2025-06-02T12:52:00.000000000", + "2025-06-02T12:53:00.000000000", + "2025-06-02T12:54:00.000000000", + "2025-06-02T12:55:00.000000000", + "2025-06-02T12:56:00.000000000", + "2025-06-02T12:57:00.000000000", + "2025-06-02T12:58:00.000000000", + "2025-06-02T12:59:00.000000000", + "2025-06-02T13:00:00.000000000", + "2025-06-02T13:01:00.000000000", + "2025-06-02T13:02:00.000000000", + "2025-06-02T13:03:00.000000000", + "2025-06-02T13:04:00.000000000", + "2025-06-02T13:05:00.000000000", + "2025-06-02T13:06:00.000000000", + "2025-06-02T13:07:00.000000000", + "2025-06-02T13:08:00.000000000", + "2025-06-02T13:09:00.000000000", + "2025-06-02T13:10:00.000000000", + "2025-06-02T13:11:00.000000000", + "2025-06-02T13:12:00.000000000", + "2025-06-02T13:13:00.000000000", + "2025-06-02T13:14:00.000000000", + "2025-06-02T13:15:00.000000000", + "2025-06-02T13:16:00.000000000", + "2025-06-02T13:17:00.000000000", + "2025-06-02T13:18:00.000000000", + "2025-06-02T13:19:00.000000000", + "2025-06-02T13:20:00.000000000", + "2025-06-02T13:21:00.000000000", + "2025-06-02T13:22:00.000000000", + "2025-06-02T13:23:00.000000000", + "2025-06-02T13:24:00.000000000", + "2025-06-02T13:25:00.000000000", + "2025-06-02T13:26:00.000000000", + "2025-06-02T13:27:00.000000000", + "2025-06-02T13:28:00.000000000", + "2025-06-02T13:29:00.000000000", "2025-06-02T13:30:00.000000000", "2025-06-02T13:31:00.000000000", "2025-06-02T13:32:00.000000000", @@ -4883,12 +5504,11 @@ "2025-06-02T22:26:00.000000000", "2025-06-02T22:27:00.000000000", "2025-06-02T22:28:00.000000000", - "2025-06-02T22:29:00.000000000", - "2025-06-02T22:30:00.000000000" + "2025-06-02T22:29:00.000000000" ], "xaxis": "x3", "y": { - "bdata": "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", + "bdata": "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", "dtype": "f8" }, "yaxis": "y3" @@ -4904,7 +5524,8 @@ "showlegend": true, "type": "scatter", "x": [ - "2025-06-02T15:31:00.000000000", + "2025-06-02T13:37:00.000000000", + "2025-06-02T15:09:00.000000000", "2025-06-02T16:44:00.000000000", "2025-06-02T17:06:00.000000000", "2025-06-02T17:24:00.000000000", @@ -4912,7 +5533,7 @@ ], "xaxis": "x3", "y": { - "bdata": "PL1SliGO5T8KaCJseHrlP8UgsHJokeU/jLlrCfmg5T/9h/Tb14HlPw==", + "bdata": "Iv32deCc5T9+HThnRGnlPwpoImx4euU/xSCwcmiR5T+MuWsJ+aDlP/2H9NvXgeU/", "dtype": "f8" }, "yaxis": "y3" @@ -4976,15 +5597,16 @@ "showlegend": true, "type": "scatter", "x": [ + "2025-06-02T14:37:00.000000000", "2025-06-02T15:41:00.000000000", "2025-06-02T17:01:00.000000000", "2025-06-02T17:17:00.000000000", "2025-06-02T17:35:00.000000000", - "2025-06-02T22:29:00.000000000" + "2025-06-02T22:28:00.000000000" ], "xaxis": "x3", "y": { - "bdata": "eAskKH6M5T9NhA1Pr5TlP2sr9pfdk+U/sHJoke185T8ldQKaCBvmPw==", + "bdata": "eAskKH6M5T94CyQofozlP02EDU+vlOU/ayv2l92T5T+wcmiR7XzlP+kmMQisHOY/", "dtype": "f8" }, "yaxis": "y3" @@ -4998,6 +5620,126 @@ "opacity": 0.8, "type": "scatter", "x": [ + "2025-06-02T11:30:00.000000000", + "2025-06-02T11:31:00.000000000", + "2025-06-02T11:32:00.000000000", + "2025-06-02T11:33:00.000000000", + "2025-06-02T11:34:00.000000000", + "2025-06-02T11:35:00.000000000", + "2025-06-02T11:36:00.000000000", + "2025-06-02T11:37:00.000000000", + "2025-06-02T11:38:00.000000000", + "2025-06-02T11:39:00.000000000", + "2025-06-02T11:40:00.000000000", + "2025-06-02T11:41:00.000000000", + "2025-06-02T11:42:00.000000000", + "2025-06-02T11:43:00.000000000", + "2025-06-02T11:44:00.000000000", + "2025-06-02T11:45:00.000000000", + "2025-06-02T11:46:00.000000000", + "2025-06-02T11:47:00.000000000", + "2025-06-02T11:48:00.000000000", + "2025-06-02T11:49:00.000000000", + "2025-06-02T11:50:00.000000000", + "2025-06-02T11:51:00.000000000", + "2025-06-02T11:52:00.000000000", + "2025-06-02T11:53:00.000000000", + "2025-06-02T11:54:00.000000000", + "2025-06-02T11:55:00.000000000", + "2025-06-02T11:56:00.000000000", + "2025-06-02T11:57:00.000000000", + "2025-06-02T11:58:00.000000000", + "2025-06-02T11:59:00.000000000", + "2025-06-02T12:00:00.000000000", + "2025-06-02T12:01:00.000000000", + "2025-06-02T12:02:00.000000000", + "2025-06-02T12:03:00.000000000", + "2025-06-02T12:04:00.000000000", + "2025-06-02T12:05:00.000000000", + "2025-06-02T12:06:00.000000000", + "2025-06-02T12:07:00.000000000", + "2025-06-02T12:08:00.000000000", + "2025-06-02T12:09:00.000000000", + "2025-06-02T12:10:00.000000000", + "2025-06-02T12:11:00.000000000", + "2025-06-02T12:12:00.000000000", + "2025-06-02T12:13:00.000000000", + "2025-06-02T12:14:00.000000000", + "2025-06-02T12:15:00.000000000", + "2025-06-02T12:16:00.000000000", + "2025-06-02T12:17:00.000000000", + "2025-06-02T12:18:00.000000000", + "2025-06-02T12:19:00.000000000", + "2025-06-02T12:20:00.000000000", + "2025-06-02T12:21:00.000000000", + "2025-06-02T12:22:00.000000000", + "2025-06-02T12:23:00.000000000", + "2025-06-02T12:24:00.000000000", + "2025-06-02T12:25:00.000000000", + "2025-06-02T12:26:00.000000000", + "2025-06-02T12:27:00.000000000", + "2025-06-02T12:28:00.000000000", + "2025-06-02T12:29:00.000000000", + "2025-06-02T12:30:00.000000000", + "2025-06-02T12:31:00.000000000", + "2025-06-02T12:32:00.000000000", + "2025-06-02T12:33:00.000000000", + "2025-06-02T12:34:00.000000000", + "2025-06-02T12:35:00.000000000", + "2025-06-02T12:36:00.000000000", + "2025-06-02T12:37:00.000000000", + "2025-06-02T12:38:00.000000000", + "2025-06-02T12:39:00.000000000", + "2025-06-02T12:40:00.000000000", + "2025-06-02T12:41:00.000000000", + "2025-06-02T12:42:00.000000000", + "2025-06-02T12:43:00.000000000", + "2025-06-02T12:44:00.000000000", + "2025-06-02T12:45:00.000000000", + "2025-06-02T12:46:00.000000000", + "2025-06-02T12:47:00.000000000", + "2025-06-02T12:48:00.000000000", + "2025-06-02T12:49:00.000000000", + "2025-06-02T12:50:00.000000000", + "2025-06-02T12:51:00.000000000", + "2025-06-02T12:52:00.000000000", + "2025-06-02T12:53:00.000000000", + "2025-06-02T12:54:00.000000000", + "2025-06-02T12:55:00.000000000", + "2025-06-02T12:56:00.000000000", + "2025-06-02T12:57:00.000000000", + "2025-06-02T12:58:00.000000000", + "2025-06-02T12:59:00.000000000", + "2025-06-02T13:00:00.000000000", + "2025-06-02T13:01:00.000000000", + "2025-06-02T13:02:00.000000000", + "2025-06-02T13:03:00.000000000", + "2025-06-02T13:04:00.000000000", + "2025-06-02T13:05:00.000000000", + "2025-06-02T13:06:00.000000000", + "2025-06-02T13:07:00.000000000", + "2025-06-02T13:08:00.000000000", + "2025-06-02T13:09:00.000000000", + "2025-06-02T13:10:00.000000000", + "2025-06-02T13:11:00.000000000", + "2025-06-02T13:12:00.000000000", + "2025-06-02T13:13:00.000000000", + "2025-06-02T13:14:00.000000000", + "2025-06-02T13:15:00.000000000", + "2025-06-02T13:16:00.000000000", + "2025-06-02T13:17:00.000000000", + "2025-06-02T13:18:00.000000000", + "2025-06-02T13:19:00.000000000", + "2025-06-02T13:20:00.000000000", + "2025-06-02T13:21:00.000000000", + "2025-06-02T13:22:00.000000000", + "2025-06-02T13:23:00.000000000", + "2025-06-02T13:24:00.000000000", + "2025-06-02T13:25:00.000000000", + "2025-06-02T13:26:00.000000000", + "2025-06-02T13:27:00.000000000", + "2025-06-02T13:28:00.000000000", + "2025-06-02T13:29:00.000000000", "2025-06-02T13:30:00.000000000", "2025-06-02T13:31:00.000000000", "2025-06-02T13:32:00.000000000", @@ -5536,12 +6278,11 @@ "2025-06-02T22:26:00.000000000", "2025-06-02T22:27:00.000000000", "2025-06-02T22:28:00.000000000", - "2025-06-02T22:29:00.000000000", - "2025-06-02T22:30:00.000000000" + "2025-06-02T22:29:00.000000000" ], "xaxis": "x4", "y": { - "bdata": "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", + "bdata": "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", "dtype": "f8" }, "yaxis": "y4" @@ -5581,15 +6322,16 @@ "showlegend": true, "type": "scatter", "x": [ + "2025-06-02T14:37:00.000000000", "2025-06-02T15:41:00.000000000", "2025-06-02T17:01:00.000000000", "2025-06-02T17:17:00.000000000", "2025-06-02T17:35:00.000000000", - "2025-06-02T22:29:00.000000000" + "2025-06-02T22:28:00.000000000" ], "xaxis": "x4", "y": { - "bdata": "MzMzMzMjY0AK16NwPSJjQHsUrkfhImNASOF6FK4fY0BmZmZmZpZjQA==", + "bdata": "ZmZmZmY2Y0AzMzMzMyNjQArXo3A9ImNAexSuR+EiY0BI4XoUrh9jQAAAAAAAmGNA", "dtype": "f8" }, "yaxis": "y4" @@ -5605,7 +6347,8 @@ "showlegend": true, "type": "scatter", "x": [ - "2025-06-02T15:31:00.000000000", + "2025-06-02T13:37:00.000000000", + "2025-06-02T15:09:00.000000000", "2025-06-02T16:44:00.000000000", "2025-06-02T17:06:00.000000000", "2025-06-02T17:24:00.000000000", @@ -5613,7 +6356,7 @@ ], "xaxis": "x4", "y": { - "bdata": "SOF6FK4nY0C4HoXrURBjQClcj8L1IGNAZmZmZmY2Y0Bcj8L1KARjQA==", + "bdata": "CtejcD1KY0D2KFyPwgVjQLgehetREGNAKVyPwvUgY0BmZmZmZjZjQFyPwvUoBGNA", "dtype": "f8" }, "yaxis": "y4" @@ -5709,8 +6452,8 @@ }, "opacity": 0.7, "type": "line", - "x0": "2025-06-02T13:30:00", - "x1": "2025-06-02T22:30:00", + "x0": "2025-06-02T11:30:00", + "x1": "2025-06-02T22:29:00", "xref": "x", "y0": 2, "y1": 2, @@ -5724,8 +6467,8 @@ }, "opacity": 0.7, "type": "line", - "x0": "2025-06-02T13:30:00", - "x1": "2025-06-02T22:30:00", + "x0": "2025-06-02T11:30:00", + "x1": "2025-06-02T22:29:00", "xref": "x", "y0": -2, "y1": -2, @@ -5739,8 +6482,8 @@ }, "opacity": 0.7, "type": "line", - "x0": "2025-06-02T13:30:00", - "x1": "2025-06-02T22:30:00", + "x0": "2025-06-02T11:30:00", + "x1": "2025-06-02T22:29:00", "xref": "x", "y0": 0.5, "y1": 0.5, @@ -5754,8 +6497,8 @@ }, "opacity": 0.7, "type": "line", - "x0": "2025-06-02T13:30:00", - "x1": "2025-06-02T22:30:00", + "x0": "2025-06-02T11:30:00", + "x1": "2025-06-02T22:29:00", "xref": "x", "y0": -0.5, "y1": -0.5, @@ -5769,8 +6512,8 @@ }, "opacity": 0.5, "type": "line", - "x0": "2025-06-02T13:30:00", - "x1": "2025-06-02T22:30:00", + "x0": "2025-06-02T11:30:00", + "x1": "2025-06-02T22:29:00", "xref": "x", "y0": 0, "y1": 0, @@ -6564,8 +7307,8 @@ 1 ], "range": [ - "2025-06-02T13:30:00", - "2025-06-02T22:30:00" + "2025-06-02T11:30:00", + "2025-06-02T22:29:00" ] }, "xaxis2": { @@ -6575,8 +7318,8 @@ 1 ], "range": [ - "2025-06-02T13:30:00", - "2025-06-02T22:30:00" + "2025-06-02T11:30:00", + "2025-06-02T22:29:00" ] }, "xaxis3": { @@ -6586,8 +7329,8 @@ 1 ], "range": [ - "2025-06-02T13:30:00", - "2025-06-02T22:30:00" + "2025-06-02T11:30:00", + "2025-06-02T22:29:00" ] }, "xaxis4": { @@ -6597,8 +7340,8 @@ 1 ], "range": [ - "2025-06-02T13:30:00", - "2025-06-02T22:30:00" + "2025-06-02T11:30:00", + "2025-06-02T22:29:00" ], "title": { "text": "Time" @@ -6648,9 +7391,9 @@ }, "text/html": [ "
\n", - "