Release v1.0.1

.envrc

@@ -0,0 +1 @@
+source /home/oleg/.pyenv/python3.12-venv/bin/activate

.gitignore

@@ -3,9 +3,22 @@ __pycache__/
 __OLD__/
 .specstory/
 .history/
-.cursorindexingignore
+.vscode/
+*.py[cod]
+.ipynb_checkpoints/
+.pytest_cache/
+
+# Local environments
+.venv/
+venv/
+
+# Local test data and generated analysis results
+data/*
+!data/.gitkeep
+results/*
+!results/.gitkeep
+
 data
+
 cvttpy
-# SpecStory explanation file
+tmp/
-.specstory/.what-is-this.md
-results/

.vscode/.env

@@ -1 +0,0 @@
-PYTHONPATH=/home/oleg/develop

.vscode/extensions.json

@@ -1,9 +0,0 @@
-{
-    "recommendations": [
-        "ms-python.python",
-        "ms-python.pylance",
-        "ms-python.black-formatter",
-        "ms-python.mypy-type-checker",
-        "ms-python.isort"
-    ]
-}

.vscode/launch.json

@@ -1,271 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-    
-
-        {
-            "name": "Python Debugger: Current File",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${file}",
-            "console": "integratedTerminal",
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib:${workspaceFolder}/.."
-            },
-        },
-        {
-            "name": "-------- Live Pair Trading --------",
-        },
-        {
-            "name": "PAIRS TRADER",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/bin/pairs_trader.py",
-            "console": "integratedTerminal",
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib:${workspaceFolder}/.."
-            },
-            "args": [
-                "--config=${workspaceFolder}/configuration/pairs_trader.cfg",
-                "--pair=PAIR-ADA-USDT:BNBSPOT,PAIR-SOL-USDT:BNBSPOT",
-            ],
-        },
-        {
-            "name": "-------- OLS --------",
-        },
-        {
-            "name": "CRYPTO OLS (rolling)",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/ols.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=20250605",
-                "--result_db=${workspaceFolder}/research/results/crypto/%T.ols.ADA-SOL.20250605.crypto_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "CRYPTO OLS (optimized)",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/ols-opt.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=20250605",
-                "--result_db=${workspaceFolder}/research/results/crypto/%T.ols-opt.ADA-SOL.20250605.crypto_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        // {
-        //     "name": "CRYPTO OLS (expanding)",
-        //     "type": "debugpy",
-        //     "request": "launch",
-        //     "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-        //     "program": "${workspaceFolder}/research/backtest.py",
-        //     "args": [
-        //         "--config=${workspaceFolder}/configuration/ols-exp.cfg",
-        //         "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-        //         "--date_pattern=20250605",
-        //         "--result_db=${workspaceFolder}/research/results/crypto/%T.ols-exp.ADA-SOL.20250605.crypto_results.db",            
-        //     ],
-        //     "env": {
-        //         "PYTHONPATH": "${workspaceFolder}/lib"
-        //     },
-        //     "console": "integratedTerminal"
-        // },
-        {
-            "name": "EQUITY OLS (rolling)",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/ols.cfg",
-                "--instruments=COIN:EQUITY:ALPACA,MSTR:EQUITY:ALPACA",
-                "--date_pattern=20250605",
-                "--result_db=${workspaceFolder}/research/results/equity/%T.ols.COIN-MSTR.20250605.equity_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "EQUITY-CRYPTO OLS (rolling)",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/ols.cfg",
-                "--instruments=COIN:EQUITY:ALPACA,BTC-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=20250605",
-                "--result_db=${workspaceFolder}/research/results/intermarket/%T.ols.COIN-BTC.20250605.equity_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-       {
-            "name": "-------- VECM --------",
-        },
-        {
-            "name": "CRYPTO VECM (rolling)",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/vecm.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=20250605",
-                "--result_db=${workspaceFolder}/research/results/crypto/%T.vecm.ADA-SOL.20250605.crypto_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "CRYPTO VECM (optimized)",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/vecm-opt.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=20250605",
-                "--result_db=${workspaceFolder}/research/results/crypto/%T.vecm-opt.ADA-SOL.20250605.crypto_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        // {
-        //     "name": "CRYPTO VECM (expanding)",
-        //     "type": "debugpy",
-        //     "request": "launch",
-        //     "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-        //     "program": "${workspaceFolder}/research/backtest.py",
-        //     "args": [
-        //         "--config=${workspaceFolder}/configuration/vecm-exp.cfg",
-        //         "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-        //         "--date_pattern=20250605",
-        //         "--result_db=${workspaceFolder}/research/results/crypto/%T.vecm-exp.ADA-SOL.20250605.crypto_results.db",            
-        //     ],
-        //     "env": {
-        //         "PYTHONPATH": "${workspaceFolder}/lib"
-        //     },
-        //     "console": "integratedTerminal"
-        // },
-        {
-            "name": "EQUITY VECM (rolling)",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/vecm.cfg",
-                "--instruments=COIN:EQUITY:ALPACA,MSTR:EQUITY:ALPACA",
-                "--date_pattern=20250605",
-                "--result_db=${workspaceFolder}/research/results/equity/%T.vecm.COIN-MSTR.20250605.equity_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "EQUITY-CRYPTO VECM (rolling)",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/vecm.cfg",
-                "--instruments=COIN:EQUITY:ALPACA,BTC-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=20250605",
-                "--result_db=${workspaceFolder}/research/results/intermarket/%T.vecm.COIN-BTC.20250601.equity_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "-------- B a t c h e s --------",
-        },
-        {
-            "name": "CRYPTO OLS Batch (rolling)",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/ols.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=2025060*",
-                "--result_db=${workspaceFolder}/research/results/crypto/%T.ols.ADA-SOL.2025060-.crypto_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "CRYPTO VECM Batch (rolling)",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/vecm.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=2025060*",
-                "--result_db=${workspaceFolder}/research/results/crypto/%T.vecm.ADA-SOL.2025060-.crypto_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "-------- Viz Test --------",
-        },
-        {
-            "name": "Viz Test",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/tests/viz_test.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/ols.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=20250605",
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        }
-    ]
-}

.vscode/pairs_trading.code-workspace

@@ -1,8 +0,0 @@
-{
-	"folders": [
-		{
-			"path": ".."
-		}
-	],
-	"settings": {}
-}

.vscode/settings.json

@@ -1,112 +0,0 @@
-{
-    "PythonVersion": "3.12",
-    "[python]": {
-        "editor.defaultFormatter": "ms-python.black-formatter"
-    },
-    // ===========================================================
-    "workbench.activityBar.orientation": "vertical",
-    // ===========================================================
-
-    // "markdown.styles": [
-    //     "/home/oleg/develop/cvtt2/.vscode/light-theme.css"
-    // ],
-    "markdown.preview.background": "#ffffff",
-    "markdown.preview.textEditorTheme": "light",
-    "markdown-pdf.styles": [
-        "/home/oleg/develop/cvtt2/.vscode/light-theme.css"
-    ],
-    "editor.detectIndentation": false,
-	// Configure editor settings to be overridden for [yaml] language.
-	"[yaml]":  {
-		"editor.insertSpaces": true,
-		"editor.tabSize": 4,
-	},
-    "pylint.args": [
-        "--disable=missing-docstring"
-        , "--disable=invalid-name"
-        , "--disable=too-few-public-methods"
-        , "--disable=broad-exception-raised"
-        , "--disable=broad-exception-caught"
-        , "--disable=pointless-string-statement"
-        , "--disable=unused-argument"
-        , "--disable=line-too-long"
-        , "--disable=import-outside-toplevel"
-        , "--disable=fixme"
-        , "--disable=protected-access"
-        , "--disable=logging-fstring-interpolation"
-    ],
-    
-    // ===== TESTING CONFIGURATION =====
-    "python.testing.unittestEnabled": false,
-    "python.testing.pytestEnabled": true,
-    "python.testing.pytestArgs": [
-        "-v",
-        "--tb=short",
-        "--disable-warnings"
-    ],
-    "python.testing.envVars": {
-        "PYTHONPATH": "${workspaceFolder}/lib:${workspaceFolder}/.."
-    },
-    "python.testing.cwd": "${workspaceFolder}",
-    "python.testing.autoTestDiscoverOnSaveEnabled": true,
-    "python.testing.pytestPath": "/home/oleg/.pyenv/python3.12-venv/bin/pytest",
-    "python.testing.promptToConfigure": false,
-    "python.testing.pytest.enabled": true,
-    
-   
-    // Python interpreter settings
-    "python.defaultInterpreterPath": "/home/oleg/.pyenv/python3.12-venv/bin/python3.12",
-    
-    // Environment variables for Python execution
-    "python.envFile": "${workspaceFolder}/.vscode/.env",
-    "python.terminal.activateEnvironment": false,
-    "python.terminal.activateEnvInCurrentTerminal": false,
-    
-    // Global environment variables for VS Code Python extension
-    "terminal.integrated.env.linux": {
-        "PYTHONPATH": "/home/oleg/develop/:${env:PYTHONPATH}"
-    },
-    
-    "pylint.enabled": true,
-    "github.copilot.enable": false,
-    "markdown.extension.print.theme": "dark",
-    "python.analysis.extraPaths": [
-        "${workspaceFolder}/..", 
-        "${workspaceFolder}/lib"
-    ],
-    
-    // Try enabling regular Python language server alongside CursorPyright
-    "python.languageServer": "None",
-    "python.analysis.diagnosticMode": "workspace",
-    "workbench.colorTheme": "Atom One Dark",
-    "cursorpyright.analysis.enable": false,
-    "cursorpyright.analysis.extraPaths": [
-        "${workspaceFolder}/..", 
-        "${workspaceFolder}/lib"
-    ],
-    
-    // Enable quick fixes for unused imports
-    "python.analysis.autoImportCompletions": true,
-    "python.analysis.fixAll": ["source.unusedImports"],
-    "python.analysis.typeCheckingMode": "basic",
-    
-    // Enable code actions for CursorPyright
-    "cursorpyright.analysis.autoImportCompletions": true,
-    "cursorpyright.analysis.typeCheckingMode": "off",
-    "cursorpyright.reportUnusedImport": "warning",
-    "cursorpyright.reportUnusedVariable": "warning",
-    "cursorpyright.analysis.diagnosticMode": "workspace",
-    
-    // Force enable code actions
-    "editor.lightBulb.enabled": true,
-    "editor.codeActionsOnSave": {
-        "source.organizeImports": "explicit",
-        "source.fixAll": "explicit",
-        "source.unusedImports": "explicit"
-    },
-    
-    // Enable Python-specific code actions
-    "python.analysis.completeFunctionParens": true,
-    "python.analysis.addImport.exactMatchOnly": false,
-    "workbench.tree.indent": 24,
-}

AGENTS.md

@@ -0,0 +1,156 @@
+# Agent Instructions
+
+## Repository purpose
+
+This repository analyzes test results with Jupyter notebooks and Python or
+Bash scripts. Inputs are commonly SQLite databases containing time-series data
+and JSON columns, but analyses may use other test-result formats.
+
+Ignore `__SAV__/`. It is unrelated legacy material, is not part of the active
+project, and must not be read, edited, moved, or used as a source of conventions
+unless the user explicitly requests it.
+
+## Active layout
+
+- `notebooks/`: exploratory and report-oriented Jupyter notebooks.
+- `scripts/`: reusable Python and Bash analysis utilities.
+- `data/`: local input data. Contents are ignored except for `.gitkeep`.
+- `results/`: generated tables, figures, exports, and reports. Contents are
+  ignored except for `.gitkeep`.
+- `requirements.txt`: Python dependencies needed to reproduce repository work.
+
+Keep reusable logic in `scripts/` and use notebooks to orchestrate analysis,
+explain decisions, and present results. Do not create a separate `analysis/`
+tree.
+
+## Python environment
+
+The intended virtual environment is `~/.pyenv/python3.12-venv`.
+
+```bash
+source ~/.pyenv/python3.12-venv/bin/activate
+python -m pip install -r requirements.txt
+```
+
+Agents may install packages in this environment when needed. Whenever a package
+is installed for repository work, update `requirements.txt` in the same change
+with a suitable direct dependency declaration. Use `python -m pip`, not bare
+`pip`, in documented commands.
+
+Do not create an in-repository virtual environment unless the user asks for
+one.
+
+## Data handling
+
+- Treat files in `data/` as local, potentially large, and potentially
+  sensitive.
+- Do not commit SQLite databases, raw test results, or generated results.
+- Do not modify source data in place. Write transformed data and exports under
+  `results/`.
+- Use parameterized SQL for values. Do not construct SQL by interpolating
+  untrusted data.
+- Parse JSON columns defensively and preserve missing, malformed, and unexpected
+  values unless the analysis explicitly defines another policy.
+- State assumptions about timestamps, time zones, ordering, units, and duplicate
+  observations in the notebook or script that relies on them.
+- Avoid loading entire databases into memory when a filtered query or chunked
+  read is practical.
+
+## Notebook conventions
+
+- A notebook must run from a fresh kernel, top to bottom, without relying on
+  hidden interactive state.
+- Set random seeds where nondeterminism affects results.
+- Keep data paths relative to the repository root and avoid machine-specific
+  absolute paths.
+- Move logic that is reused or substantial enough to test into `scripts/`.
+- Clear cell outputs before committing notebooks. Never commit embedded source
+  data, credentials, or bulky generated output.
+- Keep concise Markdown context near analyses: purpose, input assumptions,
+  method, and interpretation.
+
+## Scripts
+
+- Python scripts should expose reusable functions and use a guarded CLI entry
+  point when executable.
+- Bash scripts must start with `#!/usr/bin/env bash` and use
+  `set -euo pipefail`.
+- Prefer explicit CLI arguments over hard-coded paths or parameters.
+- Fail with actionable error messages when required data, tables, columns, or
+  configuration are missing.
+
+## Verification
+
+Verification should be proportional to the change. At minimum:
+
+- Run `pytest` for Python script changes.
+- Add or update tests for reusable parsing, transformation, query, and
+  calculation logic.
+- Execute changed notebooks from a fresh kernel with `nbmake`.
+- Run changed Bash scripts against a safe fixture or exercise their
+  non-destructive validation/help path.
+- Clear notebook outputs after execution and before committing.
+
+Useful commands:
+
+```bash
+python -m pytest
+python -m pytest --nbmake notebooks
+jupyter nbconvert --ClearOutputPreprocessor.enabled=True --inplace path/to/notebook.ipynb
+```
+
+If verification cannot be run, report exactly what was skipped and why.
+
+## Release rules
+
+- Update `CHANGELOG.md` for every release with the release version, release
+  date, Git tag, and a concise summary of notable changes.
+- Keep an `Unreleased` section at the top of `CHANGELOG.md` for changes that
+  have not been included in a tagged release yet.
+- Move relevant entries from `Unreleased` into the dated release section when
+  creating a release, and leave `Unreleased` present for future changes.
+- Use release headers in `YYYY-MM-DD vMAJOR.MINOR.PATCH` form.
+- Use version numbers in `MAJOR.MINOR.PATCH` form. Start this repository at
+  `0.0.1`.
+- Use Git tags in `vMAJOR.MINOR.PATCH` form, matching the changelog version
+  exactly. For example, version `0.0.1` must be tagged as `v0.0.1`.
+- Create the Git tag only after the changelog and any release-related version
+  changes are complete.
+- When the user requests creating a release, treat that as explicit permission
+  to commit the release changes, create the matching Git tag, and push both the
+  branch and tag.
+- Do not push release commits or tags unless the user explicitly requests it.
+
+## Mandatory background review
+
+Changes to Python scripts, Bash scripts, or notebook code cells require approval
+from a separate background reviewer agent before the implementing agent may
+declare the work complete.
+
+The implementing agent must:
+
+1. Finish the implementation and run the relevant verification.
+2. Ask a separate background agent to review the diff for correctness,
+   reproducibility, data safety, and test coverage.
+3. Address every material finding, rerun affected checks, and request follow-up
+   review when the fix materially changes the code.
+4. Report the reviewer outcome in the final response.
+
+The reviewer must inspect the actual diff and relevant surrounding files; a
+self-review does not satisfy this requirement. Documentation-only,
+configuration-only, dependency-only, and ignore-rule-only changes do not
+require background approval unless they also alter Python, Bash, or notebook
+code cells.
+
+If no background reviewer is available, complete all other work but do not
+claim reviewer approval. End the handoff with the exact status:
+
+`review pending`
+
+## Change discipline
+
+- Preserve user changes and avoid unrelated cleanup.
+- Do not edit or commit generated files from `data/` or `results/`.
+- Do not push or commit unless the user explicitly requests it. The `master`
+  branch being unprotected does not imply permission to push directly.
+- Keep changes focused and explain any new assumptions or dependencies.

CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+## Unreleased
+
+No unreleased changes yet.
+
+## 2026-07-28 v1.0.1
+
+- Added the `spbt_day` notebook for interactive single-day backtest result
+  analysis, including SQLite result file selection from the local data
+  directory.
+- Added selector-pair loading and dense ranking by `mr_score.final`, preserving
+  rows with invalid score JSON for inspection.
+- Added theoretical return calculation for ranked pairs from
+  `trading_instructions`, including reusable helper functions and tests.
+- Added a Plotly histogram for visual analysis of total theoretical return by
+  pair.
+- Moved notebook support code into reusable `scripts/spbt_day.py` helpers.
+- Adjusted notebook table outputs to show all relevant rows and reduce
+  redundant intermediate displays.
+- Added an alphabetically sorted pair selector for individual pair analysis.
+- Added selected-pair theoretical execution tables and aligned TheoRet
+  calculations with target-delta trade generation.
+- Added per-asset `strength` values to selected-pair theoretical execution
+  tables.
+- Corrected theoretical execution size to use
+  `10000 * strength / reference_price`.
+- Removed `:USD` quote suffixes from displayed pair names in notebook tables,
+  chart hovers, and the pair selector dropdown while preserving full internal
+  pair keys for calculations.
+- Added `num_trades` to pair TheoRet summaries, counting asset-level theoretical
+  trades from effective `TARGET` and `CLOSE` instructions.
+- Added sortable interactive grids for the pair TheoRet and selected-pair
+  theoretical execution tables.
+- Styled interactive dataframe grids with black text on white backgrounds for
+  readability across notebook themes.
+- Added a selected-pair Plotly chart that overlays theoretical BUY/SELL
+  executions on relative 1-minute market close data for both instruments.
+- Anchored the selected-pair market chart at trading-day midnight and normalized
+  relative prices to each instrument's close at that timestamp.
+- Added a `min_pctg_change` threshold for ranked pair TheoRet calculations to
+  skip small target-strength changes after a position is acquired.
+- Added a notebook input field for the minimum TARGET strength-change threshold.
+
+## 2026-07-25 v0.0.9
+
+- Added contributing guidance and Python dependency declarations.
+- Added placeholder files for active project directories.
+- Updated ignore rules for local data, generated results, caches, and local
+  environments.
+- Documented unreleased changelog handling and release push behavior.
+
+## 2026-07-25 v0.0.1
+
+- Established the initial repository structure and project guidance.

CONTRIBUTING.md

@@ -0,0 +1,54 @@
+# Contributing
+
+## Setup
+
+Use the shared Python 3.12 virtual environment:
+
+```bash
+source ~/.pyenv/python3.12-venv/bin/activate
+python -m pip install -r requirements.txt
+```
+
+If you install another package for repository work, add its direct dependency
+to `requirements.txt`.
+
+## Repository layout
+
+- Put notebooks in `notebooks/`.
+- Put reusable Python and Bash utilities in `scripts/`.
+- Put local input files in `data/`.
+- Put generated artifacts in `results/`.
+
+The contents of `data/` and `results/` are ignored. Do not force-add test
+databases, raw test results, generated exports, or notebook outputs.
+
+`__SAV__/` is unrelated legacy material and is outside the active project.
+
+## Working with notebooks
+
+Notebooks must execute from top to bottom in a fresh kernel. Use relative paths,
+document data assumptions, and move reusable logic into tested scripts.
+
+Before handing off a change:
+
+```bash
+python -m pytest
+python -m pytest --nbmake notebooks
+jupyter nbconvert --ClearOutputPreprocessor.enabled=True --inplace path/to/notebook.ipynb
+```
+
+Run only the checks relevant to the files present in the repository, and report
+anything that could not be run.
+
+## Review requirement
+
+Python scripts, Bash scripts, and notebook code-cell changes require review and
+approval by a separate background agent. Address material findings and rerun
+affected checks before completion. If a reviewer is unavailable, the change may
+be handed off only with the status `review pending`.
+
+Documentation, dependency declarations, and ignore rules do not require this
+background review when no Python, Bash, or notebook code cells changed.
+
+The `master` branch is not protected. That does not remove the review
+requirement or authorize an agent to commit or push without an explicit request.

__DELETE__/.vscode/launch.json

@@ -1,181 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-    
-
-        {
-            "name": "Python Debugger: Current File",
-            "type": "debugpy",
-            "request": "launch",
-            "program": "${file}",
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "-------- Z-Score (OLS) --------",
-        },
-        {
-            "name": "CRYPTO z-score",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "research/pt_backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/zscore.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=20250605",
-                "--result_db=${workspaceFolder}/research/results/crypto/%T.z-score.ADA-SOL.20250602.crypto_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "EQUITY z-score",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "research/pt_backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/zscore.cfg",
-                "--instruments=COIN:EQUITY:ALPACA,MSTR:EQUITY:ALPACA",
-                "--date_pattern=2025060*",
-                "--result_db=${workspaceFolder}/research/results/equity/%T.z-score.COIN-MSTR.20250602.equity_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "EQUITY-CRYPTO z-score",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "research/pt_backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/zscore.cfg",
-                "--instruments=COIN:EQUITY:ALPACA,BTC-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=2025060*",
-                "--result_db=${workspaceFolder}/research/results/intermarket/%T.z-score.COIN-BTC.20250601.equity_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "-------- VECM --------",
-        },
-        {
-            "name": "CRYPTO vecm",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "research/pt_backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/vecm.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=2025060*",
-                "--result_db=${workspaceFolder}/research/results/crypto/%T.vecm.ADA-SOL.20250602.crypto_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "EQUITY vecm",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "research/pt_backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/vecm.cfg",
-                "--instruments=COIN:EQUITY:ALPACA,MSTR:EQUITY:ALPACA",
-                "--date_pattern=2025060*",
-                "--result_db=${workspaceFolder}/research/results/equity/%T.vecm.COIN-MSTR.20250602.equity_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "EQUITY-CRYPTO vecm",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "research/pt_backtest.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/vecm.cfg",
-                "--instruments=COIN:EQUITY:ALPACA,BTC-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=2025060*",
-                "--result_db=${workspaceFolder}/research/results/intermarket/%T.vecm.COIN-BTC.20250601.equity_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "-------- New ZSCORE --------",
-        },
-        {
-            "name": "New CRYPTO z-score",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest_new.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/new_zscore.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=2025060*",
-                "--result_db=${workspaceFolder}/research/results/crypto/%T.new_zscore.ADA-SOL.2025060-.crypto_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "New CRYPTO vecm",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/backtest_new.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/new_vecm.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=20250605",
-                "--result_db=${workspaceFolder}/research/results/crypto/%T.vecm.ADA-SOL.20250605.crypto_results.db",            
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        },
-        {
-            "name": "-------- Viz Test --------",
-        },
-        {
-            "name": "Viz Test",
-            "type": "debugpy",
-            "request": "launch",
-            "python": "/home/oleg/.pyenv/python3.12-venv/bin/python",
-            "program": "${workspaceFolder}/research/viz_test.py",
-            "args": [
-                "--config=${workspaceFolder}/configuration/new_zscore.cfg",
-                "--instruments=ADA-USDT:CRYPTO:BNBSPOT,SOL-USDT:CRYPTO:BNBSPOT",
-                "--date_pattern=20250605",
-            ],
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/lib"
-            },
-            "console": "integratedTerminal"
-        }
-    ]
-}

__DELETE__/configuration/vecm.cfg

@@ -1,44 +0,0 @@
-{
-    "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", # "vwap"
-    "execution_price": {
-        "column": "vwap",
-        "shift": 1,
-    },
-    "dis-equilibrium_open_trshld": 2.0,
-    "dis-equilibrium_close_trshld": 1.0,
-    "training_minutes": 120, # TODO Remove this
-    "training_size": 120,
-    "fit_method_class": "pt_trading.vecm_rolling_fit.VECMRollingFit",
-
-    # ====== 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",
-    }
-}

__DELETE__/configuration/zscore.cfg

@@ -1,43 +0,0 @@
-{
-    "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": "7:30:00",
-        "end_session": "18:30:00",
-    }
-}

__DELETE__/configuration/zscore_expanding.cfg

@@ -1,43 +0,0 @@
-{
-    "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",
-    }
-}

__DELETE__/lib/pt_trading/expanding_window_fit.py

@@ -1,304 +0,0 @@
-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

__DELETE__/lib/pt_trading/fit_method.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from enum import Enum
-from typing import Dict, Optional, cast
-
-import pandas as pd 
-from pt_trading.results import BacktestResult
-from pt_trading.trading_pair import TradingPair
-
-NanoPerMin = 1e9
-
-
-class PairsTradingFitMethod(ABC):
-    TRADES_COLUMNS = [
-        "time",
-        "symbol",
-        "side",
-        "action",
-        "price",
-        "disequilibrium",
-        "scaled_disequilibrium",
-        "signed_scaled_disequilibrium",
-        "pair",
-    ]
-    @staticmethod
-    def create(config: Dict) -> PairsTradingFitMethod:
-        import importlib
-        fit_method_class_name = config.get("fit_method_class", None)
-        assert fit_method_class_name is not None
-        module_name, class_name = fit_method_class_name.rsplit(".", 1)
-        module = importlib.import_module(module_name)
-        fit_method = getattr(module, class_name)()
-        return cast(PairsTradingFitMethod, fit_method)
-
-    @abstractmethod
-    def run_pair(
-        self, pair: TradingPair, bt_result: BacktestResult
-    ) -> Optional[pd.DataFrame]: ...
-
-    @abstractmethod
-    def reset(self) -> None: ...
-
-    @abstractmethod
-    def create_trading_pair(
-        self,
-        config: Dict,
-        market_data: pd.DataFrame,
-        symbol_a: str,
-        symbol_b: str,
-    ) -> TradingPair: ...
-

__DELETE__/lib/pt_trading/results.py

@@ -1,751 +0,0 @@
-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,
-                fit_method_class 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,
-    fit_method_class: str,
-    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, fit_method_class, datafiles, instruments
-            ) VALUES (?, ?, ?, ?, ?, ?)
-        """,
-            (
-                datetime.now(),
-                config_file_path,
-                config_json,
-                fit_method_class,
-                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)}")
-
-
-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:
-    """
-    Class to handle backtest results, trades tracking, PnL calculations, and reporting.
-    """
-
-    def __init__(self, config: Dict[str, Any]):
-        self.config = config
-        self.trades: Dict[str, Dict[str, Any]] = {}
-        self.total_realized_pnl = 0.0
-        self.outstanding_positions: List[Dict[str, Any]] = []
-        self.symbol_roundtrip_trades_: Dict[str, List[Dict[str, Any]]] = {}
-        
-    def add_trade(
-        self,
-        pair_nm: str,
-        symbol: str,
-        side: str,
-        action: str,
-        price: Any,
-        disequilibrium: Optional[float] = None,
-        scaled_disequilibrium: Optional[float] = None,
-        timestamp: Optional[datetime] = None,
-        status: Optional[str] = None,
-    ) -> None:
-        """Add a trade to the results tracking."""
-        pair_nm = str(pair_nm)
-
-        if pair_nm not in self.trades:
-            self.trades[pair_nm] = {symbol: []}
-        if symbol not in self.trades[pair_nm]:
-            self.trades[pair_nm][symbol] = []
-        self.trades[pair_nm][symbol].append(
-            {
-                "symbol": symbol,
-                "side": side,
-                "action": action,
-                "price": price,
-                "disequilibrium": disequilibrium,
-                "scaled_disequilibrium": scaled_disequilibrium,
-                "timestamp": timestamp,
-                "status": status,
-            }
-        )
-
-    def add_outstanding_position(self, position: Dict[str, Any]) -> None:
-        """Add an outstanding position to tracking."""
-        self.outstanding_positions.append(position)
-
-    def add_realized_pnl(self, realized_pnl: float) -> None:
-        """Add realized PnL to the total."""
-        self.total_realized_pnl += realized_pnl
-
-    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 all outstanding positions."""
-        return self.outstanding_positions
-
-    def get_trades(self) -> Dict[str, Dict[str, Any]]:
-        """Get all trades."""
-        return self.trades
-
-    def clear_trades(self) -> None:
-        """Clear all trades (used when processing new files)."""
-        self.trades.clear()
-
-    def collect_single_day_results(self, pairs_trades: List[pd.DataFrame]) -> None:
-        """Collect and process single day trading results."""
-        result = pd.concat(pairs_trades, ignore_index=True)
-        result["time"] = pd.to_datetime(result["time"])
-        result = result.set_index("time").sort_index()
-
-        print("\n --------------  Suggested Trades ")
-        print(result)
-
-        for row in result.itertuples():
-            side = row.side
-            action = row.action
-            symbol = row.symbol
-            price = row.price
-            disequilibrium = getattr(row, "disequilibrium", None)
-            scaled_disequilibrium = getattr(row, "scaled_disequilibrium", None)
-            if hasattr(row, "time"):
-                timestamp = getattr(row, "time")
-            else:
-                timestamp = convert_timestamp(row.Index)
-            status = row.status
-            self.add_trade(
-                pair_nm=str(row.pair),
-                symbol=str(symbol),
-                side=str(side),
-                action=str(action),
-                price=float(str(price)),
-                disequilibrium=disequilibrium,
-                scaled_disequilibrium=scaled_disequilibrium,
-                timestamp=timestamp,
-                status=str(status) if status is not None else "?",
-            )
-
-    def print_single_day_results(self) -> None:
-        """Print single day results summary."""
-        for pair, symbols in self.trades.items():
-            print(f"\n--- {pair} ---")
-            for symbol, trades in symbols.items():
-                for trade_data in trades:
-                    if len(trade_data) >= 2:
-                        side, price = trade_data[:2]
-                        print(f"{symbol} {side} at ${price}")
-
-    def print_results_summary(self, all_results: Dict[str, Dict[str, Any]]) -> None:
-        """Print summary of all processed files."""
-        print("\n====== Summary of All Processed Files ======")
-        for filename, data in all_results.items():
-            trade_count = sum(
-                len(trades)
-                for symbol_trades in data["trades"].values()
-                for trades in symbol_trades.values()
-            )
-            print(f"{filename}: {trade_count} trades")
-
-    def calculate_returns(self, all_results: Dict[str, Dict[str, Any]]) -> None:
-        """Calculate and print returns by day and pair."""
-        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
-
-        print("\n====== Returns By Day and Pair ======")
-
-        trades = []
-        for filename, data in all_results.items():
-            pairs = list(data["trades"].keys())
-            for pair in pairs:
-                self.symbol_roundtrip_trades_[pair] = []
-                trades_dict = data["trades"][pair]
-                for symbol in trades_dict.keys():
-                    trades.extend(trades_dict[symbol])
-            trades = sorted(trades, key=lambda x: (x["timestamp"], x["symbol"]))
-
-            print(f"\n--- {filename} ---")
-
-            self.outstanding_positions = data["outstanding_positions"]
-            
-            day_return = 0.0
-            for idx in range(0, len(trades), 4):
-                symbol_a = trades[idx]["symbol"]
-                trade_a_1 = trades[idx]
-                trade_a_2 = trades[idx + 2]
-
-                symbol_b = trades[idx + 1]["symbol"]
-                trade_b_1 = trades[idx + 1]
-                trade_b_2 = trades[idx + 3]
-
-                symbol_return = 0
-                assert (
-                    trade_a_1["timestamp"] < trade_a_2["timestamp"]
-                ), f"Trade 1: {trade_a_1['timestamp']} is not less than Trade 2: {trade_a_2['timestamp']}"
-                assert (
-                    trade_a_1["action"] == "OPEN" and trade_a_2["action"] == "CLOSE"
-                ), f"Trade 1: {trade_a_1['action']} and Trade 2: {trade_a_2['action']} are the same"
-
-                # Calculate return based on action combination
-                trade_return = 0
-                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
-
-                self.symbol_roundtrip_trades_[pair].append(
-                    {
-                        "symbol": symbol_a,
-                        "open_side": trade_a_1["side"],
-                        "open_action": trade_a_1["action"],
-                        "open_price": trade_a_1["price"],
-                        "close_side": trade_a_2["side"],
-                        "close_action": trade_a_2["action"],
-                        "close_price": trade_a_2["price"],
-                        "symbol_return": symbol_a_return,
-                        "open_disequilibrium": trade_a_1["disequilibrium"],
-                        "open_scaled_disequilibrium": trade_a_1["scaled_disequilibrium"],
-                        "close_disequilibrium": trade_a_2["disequilibrium"],
-                        "close_scaled_disequilibrium": trade_a_2["scaled_disequilibrium"],
-                        "open_time": trade_a_1["timestamp"],
-                        "close_time": trade_a_2["timestamp"],
-                        "shares": self.config["funding_per_pair"] / 2  / trade_a_1["price"],
-                        "is_completed": True,
-                        "close_condition": trade_a_2["status"],
-                        "pair_return": pair_return
-                    }
-                )
-                self.symbol_roundtrip_trades_[pair].append(
-                    {
-                        "symbol": symbol_b,
-                        "open_side": trade_b_1["side"],
-                        "open_action": trade_b_1["action"],
-                        "open_price": trade_b_1["price"],
-                        "close_side": trade_b_2["side"],
-                        "close_action": trade_b_2["action"],
-                        "close_price": trade_b_2["price"],
-                        "symbol_return": symbol_b_return,
-                        "open_disequilibrium": trade_b_1["disequilibrium"],
-                        "open_scaled_disequilibrium": trade_b_1["scaled_disequilibrium"],
-                        "close_disequilibrium": trade_b_2["disequilibrium"],
-                        "close_scaled_disequilibrium": trade_b_2["scaled_disequilibrium"],
-                        "open_time": trade_b_1["timestamp"],
-                        "close_time": trade_b_2["timestamp"],
-                        "shares": self.config["funding_per_pair"] / 2  / trade_b_1["price"],
-                        "is_completed": True,
-                        "close_condition": trade_b_2["status"],
-                        "pair_return": pair_return
-                    }
-                )
-
-
-            # Print pair returns with disequilibrium information
-            day_return = 0.0
-            if pair in self.symbol_roundtrip_trades_:
-
-                print(f"{pair}:")
-                pair_return = 0.0
-                for trd in self.symbol_roundtrip_trades_[pair]:
-                    disequil_info = ""
-                    if (
-                        trd["open_scaled_disequilibrium"] is not None
-                        and trd["open_scaled_disequilibrium"] is not None
-                    ):
-                        disequil_info = f" | Open Dis-eq: {trd['open_scaled_disequilibrium']:.2f},"
-                        f" Close Dis-eq: {trd['open_scaled_disequilibrium']:.2f}"
-
-                    print(
-                        f" {trd['open_time'].time()}-{trd['close_time'].time()}  {trd['symbol']}: "
-                        f" {trd['open_side']} @ ${trd['open_price']:.2f},"
-                        f" {trd["close_side"]} @ ${trd["close_price"]:.2f},"
-                        f" Return: {trd['symbol_return']:.2f}%{disequil_info}"
-                    )
-                    pair_return += trd["symbol_return"]
-
-                print(f"    Pair Total Return: {pair_return:.2f}%")
-                day_return += pair_return
-
-            # Print day total return and add to global realized PnL
-            if day_return != 0:
-                print(f"  Day Total Return: {day_return:.2f}%")
-                self.add_realized_pnl(day_return)
-
-    def print_outstanding_positions(self) -> None:
-        """Print all outstanding positions with share quantities and current values."""
-        if not self.get_outstanding_positions():
-            print("\n====== NO OUTSTANDING POSITIONS ======")
-            return
-
-        print(f"\n====== OUTSTANDING POSITIONS ======")
-        print(
-            f"{'Pair':<15}"
-            f" {'Symbol':<10}"
-            f" {'Side':<4}"
-            f" {'Shares':<10}"
-            f" {'Open $':<8}"
-            f" {'Current $':<10}"
-            f" {'Value $':<12}"
-            f" {'Disequilibrium':<15}"
-        )
-        print("-" * 100)
-
-        total_value = 0.0
-
-        for pos in self.get_outstanding_positions():
-            # Print position A
-            print(
-                f"{pos['pair']:<15}"
-                f" {pos['symbol_a']:<10}"
-                f" {pos['side_a']:<4}"
-                f" {pos['shares_a']:<10.2f}"
-                f" {pos['open_px_a']:<8.2f}"
-                f" {pos['current_px_a']:<10.2f}"
-                f" {pos['current_value_a']:<12.2f}"
-                f" {'':<15}"
-            )
-
-            # Print position B
-            print(
-                f"{'':<15}"
-                f" {pos['symbol_b']:<10}"
-                f" {pos['side_b']:<4}"
-                f" {pos['shares_b']:<10.2f}"
-                f" {pos['open_px_b']:<8.2f}"
-                f" {pos['current_px_b']:<10.2f}"
-                f" {pos['current_value_b']:<12.2f}"
-            )
-
-            # Print pair totals with disequilibrium info
-            print(
-                f"{'':<15}"
-                f" {'PAIR TOTAL':<10}"
-                f" {'':<4}"
-                f" {'':<10}"
-                f" {'':<8}"
-                f" {'':<10}"
-                f" {pos['total_current_value']:<12.2f}"
-            )
-
-            # Print disequilibrium details
-            print(
-                f"{'':<15}"
-                f" {'DISEQUIL':<10}"
-                f" {'':<4}"
-                f" {'':<10}"
-                f" {'':<8}"
-                f" {'':<10}"
-                f" Raw: {pos['current_disequilibrium']:<6.4f}"
-                f" Scaled: {pos['current_scaled_disequilibrium']:<6.4f}"
-            )
-
-            print("-" * 100)
-
-            total_value += pos["total_current_value"]
-
-        print(f"{'TOTAL OUTSTANDING VALUE':<80} ${total_value:<12.2f}")
-
-    def print_grand_totals(self) -> None:
-        """Print grand totals across all pairs."""
-        print(f"\n====== GRAND TOTALS ACROSS ALL PAIRS ======")
-        print(f"Total Realized PnL: {self.get_total_realized_pnl():.2f}%")
-
-    def handle_outstanding_position(
-        self,
-        pair: TradingPair,
-        pair_result_df: pd.DataFrame,
-        last_row_index: int,
-        open_side_a: str,
-        open_side_b: str,
-        open_px_a: float,
-        open_px_b: float,
-        open_tstamp: datetime,
-    ) -> Tuple[float, float, float]:
-        """
-        Handle calculation and tracking of outstanding positions when no close signal is found.
-
-        Args:
-            pair: TradingPair object
-            pair_result_df: DataFrame with pair results
-            last_row_index: Index of the last row in the data
-            open_side_a, open_side_b: Trading sides for symbols A and B
-            open_px_a, open_px_b: Opening prices for symbols A and B
-            open_tstamp: Opening timestamp
-        """
-        if pair_result_df is None or pair_result_df.empty:
-            return 0, 0, 0
-
-        last_row = pair_result_df.loc[last_row_index]
-        last_tstamp = last_row["tstamp"]
-        colname_a, colname_b = pair.exec_prices_colnames()
-        last_px_a = last_row[colname_a]
-        last_px_b = last_row[colname_b]
-
-        # Calculate share quantities based on funding per pair
-        # Split funding equally between the two positions
-        funding_per_position = self.config["funding_per_pair"] / 2
-        shares_a = funding_per_position / open_px_a
-        shares_b = funding_per_position / open_px_b
-
-        # Calculate current position values (shares * current price)
-        current_value_a = shares_a * last_px_a * (-1 if open_side_a == "SELL" else 1)
-        current_value_b = shares_b * last_px_b * (-1 if open_side_b == "SELL" else 1)
-        total_current_value = current_value_a + current_value_b
-
-        # Get disequilibrium information
-        current_disequilibrium = last_row["disequilibrium"]
-        current_scaled_disequilibrium = last_row["scaled_disequilibrium"]
-
-        # Store outstanding positions
-        self.add_outstanding_position(
-            {
-                "pair": str(pair),
-                "symbol_a": pair.symbol_a_,
-                "symbol_b": pair.symbol_b_,
-                "side_a": open_side_a,
-                "side_b": open_side_b,
-                "shares_a": shares_a,
-                "shares_b": shares_b,
-                "open_px_a": open_px_a,
-                "open_px_b": open_px_b,
-                "current_px_a": last_px_a,
-                "current_px_b": last_px_b,
-                "current_value_a": current_value_a,
-                "current_value_b": current_value_b,
-                "total_current_value": total_current_value,
-                "open_time": open_tstamp,
-                "last_time": last_tstamp,
-                "current_abs_term": current_scaled_disequilibrium,
-                "current_disequilibrium": current_disequilibrium,
-                "current_scaled_disequilibrium": current_scaled_disequilibrium,
-            }
-        )
-
-        # Print position details
-        print(f"{pair}: NO CLOSE SIGNAL FOUND - Position held until end of session")
-        print(f"  Open: {open_tstamp} | Last: {last_tstamp}")
-        print(
-            f"  {pair.symbol_a_}: {open_side_a} {shares_a:.2f} shares @ ${open_px_a:.2f} -> ${last_px_a:.2f} | Value: ${current_value_a:.2f}"
-        )
-        print(
-            f"  {pair.symbol_b_}: {open_side_b} {shares_b:.2f} shares @ ${open_px_b:.2f} -> ${last_px_b:.2f} | Value: ${current_value_b:.2f}"
-        )
-        print(f"  Total Value: ${total_current_value:.2f}")
-        print(
-            f"  Disequilibrium: {current_disequilibrium:.4f} | Scaled: {current_scaled_disequilibrium:.4f}"
-        )
-
-        return current_value_a, current_value_b, total_current_value
-    
-    def store_results_in_database(
-        self, db_path: str, day: str
-    ) -> None:
-        """
-        Store backtest results in the SQLite database.
-        """
-        if db_path.upper() == "NONE":
-            return
-
-        try:
-            # Extract date from datafile name (assuming format like 20250528.mktdata.ohlcv.db)
-            date_str = day
-
-            # Convert to proper date format
-            try:
-                date_obj = datetime.strptime(date_str, "%Y%m%d").date()
-            except ValueError:
-                # If date parsing fails, use current date
-                date_obj = datetime.now().date()
-
-            conn = sqlite3.connect(db_path)
-            cursor = conn.cursor()
-
-            # Process each trade from bt_result
-            trades = self.get_trades()
-
-            for pair_name, _ in trades.items():
-
-                # Second pass: insert completed trade records into database
-                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(
-                        """
-                        INSERT INTO pt_bt_results (
-                            date, pair, symbol, open_time, open_side, open_price, 
-                            open_quantity, open_disequilibrium, close_time, close_side, 
-                            close_price, close_quantity, close_disequilibrium, 
-                            symbol_return, pair_return, close_condition
-                        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                    """,
-                        (
-                            date_obj,
-                            pair_name,
-                            trade_pair["symbol"],
-                            trade_pair["open_time"],
-                            trade_pair["open_side"],
-                            trade_pair["open_price"],
-                            trade_pair["shares"],
-                            trade_pair["open_scaled_disequilibrium"],
-                            trade_pair["close_time"],
-                            trade_pair["close_side"],
-                            trade_pair["close_price"],
-                            trade_pair["shares"],
-                            trade_pair["close_scaled_disequilibrium"],
-                            trade_pair["symbol_return"],
-                            trade_pair["pair_return"],
-                            trade_pair["close_condition"]
-                        ),
-                    )
-
-            # Store outstanding positions in separate table
-            outstanding_positions = self.get_outstanding_positions()
-            for pos in outstanding_positions:
-                # Calculate position quantity (negative for SELL positions)
-                position_qty_a = (
-                    pos["shares_a"] if pos["side_a"] == "BUY" else -pos["shares_a"]
-                )
-                position_qty_b = (
-                    pos["shares_b"] if pos["side_b"] == "BUY" else -pos["shares_b"]
-                )
-
-                # Calculate unrealized returns
-                # For symbol A: (current_price - open_price) / open_price * 100 * position_direction
-                unrealized_return_a = (
-                    (pos["current_px_a"] - pos["open_px_a"]) / pos["open_px_a"] * 100
-                ) * (1 if pos["side_a"] == "BUY" else -1)
-                unrealized_return_b = (
-                    (pos["current_px_b"] - pos["open_px_b"]) / pos["open_px_b"] * 100
-                ) * (1 if pos["side_b"] == "BUY" else -1)
-
-                # Store outstanding position for symbol A
-                cursor.execute(
-                    """
-                    INSERT INTO outstanding_positions (
-                        date, pair, symbol, position_quantity, last_price, unrealized_return, open_price, open_side
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                """,
-                    (
-                        date_obj,
-                        pos["pair"],
-                        pos["symbol_a"],
-                        position_qty_a,
-                        pos["current_px_a"],
-                        unrealized_return_a,
-                        pos["open_px_a"],
-                        pos["side_a"],
-                    ),
-                )
-
-                # Store outstanding position for symbol B
-                cursor.execute(
-                    """
-                    INSERT INTO outstanding_positions (
-                        date, pair, symbol, position_quantity, last_price, unrealized_return, open_price, open_side
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                """,
-                    (
-                        date_obj,
-                        pos["pair"],
-                        pos["symbol_b"],
-                        position_qty_b,
-                        pos["current_px_b"],
-                        unrealized_return_b,
-                        pos["open_px_b"],
-                        pos["side_b"],
-                    ),
-                )
-
-            conn.commit()
-            conn.close()
-
-        except Exception as e:
-            print(f"Error storing results in database: {str(e)}")
-            import traceback
-
-            traceback.print_exc()
-

__DELETE__/lib/pt_trading/rolling_window_fit.py

@@ -1,319 +0,0 @@
-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
-from statsmodels.tsa.vector_ar.vecm import VECM, VECMResults
-
-NanoPerMin = 1e9
-
-
-class RollingFit(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_
-
-        curr_training_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"]
-        curr_predicted_row_idx = 0
-        while True:
-            print(curr_training_start_idx, end="\r")
-            pair.get_datasets(
-                training_minutes=training_minutes,
-                training_start_index=curr_training_start_idx,
-                testing_size=1,
-            )
-
-            if len(pair.training_df_) < training_minutes:
-                print(
-                    f"{pair}: current offset={curr_training_start_idx}"
-                    f" * Training data length={len(pair.training_df_)} < {training_minutes}"
-                    " * Not enough training data. Completing the job."
-                )
-                break
-
-            try:
-                # ================================ PREDICTION ================================
-                self.pair_predict_result_ = pair.predict()
-            except Exception as e:
-                raise RuntimeError(
-                    f"{pair}: TrainingPrediction failed: {str(e)}"
-                ) from e
-
-                # break
-
-            curr_training_start_idx += 1
-            if curr_training_start_idx > end_index:
-                break
-            curr_predicted_row_idx += 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

__DELETE__/lib/pt_trading/trading_pair.py

@@ -1,380 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from enum import Enum
-from typing import Any, Dict, List, Optional
-
-import pandas as pd  # type:ignore
-
-
-class PairState(Enum):
-    INITIAL = 1
-    OPEN = 2
-    CLOSE = 3
-    CLOSE_POSITION = 4
-    CLOSE_STOP_LOSS = 5
-    CLOSE_STOP_PROFIT = 6
-
-class CointegrationData:
-    EG_PVALUE_THRESHOLD = 0.05
-
-    tstamp_: pd.Timestamp
-    pair_: str
-    eg_pvalue_: float
-    johansen_lr1_: float
-    johansen_cvt_: float
-    eg_is_cointegrated_: bool
-    johansen_is_cointegrated_: bool
-
-    def __init__(self, pair: TradingPair):
-        training_df = pair.training_df_
-
-        assert training_df is not None
-        from statsmodels.tsa.vector_ar.vecm import coint_johansen
-
-        df = training_df[pair.colnames()].reset_index(drop=True)
-
-        # Run Johansen cointegration test
-        result = coint_johansen(df, det_order=0, k_ar_diff=1)
-        self.johansen_lr1_ = result.lr1[0]
-        self.johansen_cvt_ = result.cvt[0, 1]
-        self.johansen_is_cointegrated_ = self.johansen_lr1_ > self.johansen_cvt_
-
-        # Run Engle-Granger cointegration test
-        from statsmodels.tsa.stattools import coint  # type: ignore
-
-        col1, col2 = pair.colnames()
-        assert training_df is not None
-        series1 = training_df[col1].reset_index(drop=True)
-        series2 = training_df[col2].reset_index(drop=True)
-
-        self.eg_pvalue_ = float(coint(series1, series2)[1])
-        self.eg_is_cointegrated_ = bool(self.eg_pvalue_ < self.EG_PVALUE_THRESHOLD)
-
-        self.tstamp_ = training_df.index[-1]
-        self.pair_ = pair.name()
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "tstamp": self.tstamp_,
-            "pair": self.pair_,
-            "eg_pvalue": self.eg_pvalue_,
-            "johansen_lr1": self.johansen_lr1_,
-            "johansen_cvt": self.johansen_cvt_,
-            "eg_is_cointegrated": self.eg_is_cointegrated_,
-            "johansen_is_cointegrated": self.johansen_is_cointegrated_,
-        }
-
-    def __repr__(self) -> str:
-        return f"CointegrationData(tstamp={self.tstamp_}, pair={self.pair_}, eg_pvalue={self.eg_pvalue_}, johansen_lr1={self.johansen_lr1_}, johansen_cvt={self.johansen_cvt_}, eg_is_cointegrated={self.eg_is_cointegrated_}, johansen_is_cointegrated={self.johansen_is_cointegrated_})"
-
-
-class TradingPair(ABC):
-    market_data_: pd.DataFrame
-    symbol_a_: str
-    symbol_b_: str
-    stat_model_price_: str
-
-    training_mu_: float
-    training_std_: float
-
-    training_df_: pd.DataFrame
-    testing_df_: pd.DataFrame
-
-    user_data_: Dict[str, Any]
-
-    # predicted_df_: Optional[pd.DataFrame]
-
-    def __init__(
-        self,
-        config: Dict[str, Any],
-        market_data: pd.DataFrame,
-        symbol_a: str,
-        symbol_b: str,
-    ):
-        self.symbol_a_ = symbol_a
-        self.symbol_b_ = symbol_b
-        self.stat_model_price_ = config["stat_model_price"]
-        self.user_data_ = {}
-        self.predicted_df_ = None
-        self.config_ = config
-
-        self._set_market_data(market_data)
-
-    def _set_market_data(self, market_data: pd.DataFrame) -> None:
-        self.market_data_ = pd.DataFrame(
-            self._transform_dataframe(market_data)[["tstamp"] + self.colnames()]
-        )
-
-        self.market_data_ = self.market_data_.dropna().reset_index(drop=True)
-        self.market_data_["tstamp"] = pd.to_datetime(self.market_data_["tstamp"])
-        self.market_data_ = self.market_data_.sort_values("tstamp")
-        self._set_execution_price_data()
-        pass
-        
-    def _set_execution_price_data(self) -> None:
-        if "execution_price" not in self.config_:
-            self.market_data_[f"exec_price_{self.symbol_a_}"] = self.market_data_[f"{self.stat_model_price_}_{self.symbol_a_}"]
-            self.market_data_[f"exec_price_{self.symbol_b_}"] = self.market_data_[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_[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)
-
-        
-        
-
-    def get_begin_index(self) -> int:
-        if "trading_hours" not in self.config_:
-            return 0
-        assert "timezone" in self.config_["trading_hours"]
-        assert "begin_session" in self.config_["trading_hours"]
-        start_time = (
-            pd.to_datetime(self.config_["trading_hours"]["begin_session"])
-            .tz_localize(self.config_["trading_hours"]["timezone"])
-            .time()
-        )
-        mask = self.market_data_["tstamp"].dt.time >= start_time
-        return int(self.market_data_.index[mask].min())
-
-    def get_end_index(self) -> int:
-        if "trading_hours" not in self.config_:
-            return 0
-        assert "timezone" in self.config_["trading_hours"]
-        assert "end_session" in self.config_["trading_hours"]
-        end_time = (
-            pd.to_datetime(self.config_["trading_hours"]["end_session"])
-            .tz_localize(self.config_["trading_hours"]["timezone"])
-            .time()
-        )
-        mask = self.market_data_["tstamp"].dt.time <= end_time
-        return int(self.market_data_.index[mask].max())
-
-    def _transform_dataframe(self, df: pd.DataFrame) -> pd.DataFrame:
-        # Select only the columns we need
-        df_selected: pd.DataFrame = pd.DataFrame(
-            df[["tstamp", "symbol", self.stat_model_price_]]
-        )
-
-        # Start with unique timestamps
-        result_df: pd.DataFrame = (
-            pd.DataFrame(df_selected["tstamp"]).drop_duplicates().reset_index(drop=True)
-        )
-
-        # For each unique symbol, add a corresponding close 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}"
-
-            # Create temporary dataframe with timestamp and price
-            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 get_datasets(
-        self,
-        training_minutes: int,
-        training_start_index: int = 0,
-        testing_size: Optional[int] = None,
-    ) -> None:
-
-        testing_start_index = training_start_index + training_minutes
-        self.training_df_ = self.market_data_.iloc[
-            training_start_index:testing_start_index, :training_minutes
-        ].copy()
-        assert self.training_df_ is not None
-        self.training_df_ = self.training_df_.dropna().reset_index(drop=True)
-
-        testing_start_index = training_start_index + training_minutes
-        if testing_size is None:
-            self.testing_df_ = self.market_data_.iloc[testing_start_index:, :].copy()
-        else:
-            self.testing_df_ = self.market_data_.iloc[
-                testing_start_index : testing_start_index + testing_size, :
-            ].copy()
-        assert self.testing_df_ is not None
-        self.testing_df_ = self.testing_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 exec_prices_colnames(self) -> List[str]:
-        return [
-            f"exec_price_{self.symbol_a_}",
-            f"exec_price_{self.symbol_b_}",
-        ]
-
-    def add_trades(self, trades: pd.DataFrame) -> None:
-        if self.user_data_["trades"] is None or len(self.user_data_["trades"]) == 0:
-            # If trades is empty or None, just assign the new trades directly
-            self.user_data_["trades"] = trades.copy()
-        else:
-            # Ensure both DataFrames have the same columns and dtypes before concatenation
-            existing_trades = self.user_data_["trades"]
-
-            # If existing trades is empty, just assign the new trades
-            if len(existing_trades) == 0:
-                self.user_data_["trades"] = trades.copy()
-            else:
-                # Ensure both DataFrames have the same columns
-                if set(existing_trades.columns) != set(trades.columns):
-                    # Add missing columns to trades with appropriate default values
-                    for col in existing_trades.columns:
-                        if col not in trades.columns:
-                            if col == "time":
-                                trades[col] = pd.Timestamp.now()
-                            elif col in ["action", "symbol"]:
-                                trades[col] = ""
-                            elif col in [
-                                "price",
-                                "disequilibrium",
-                                "scaled_disequilibrium",
-                            ]:
-                                trades[col] = 0.0
-                            elif col == "pair":
-                                trades[col] = None
-                            else:
-                                trades[col] = None
-
-                # Concatenate with explicit dtypes to avoid warnings
-                self.user_data_["trades"] = pd.concat(
-                    [existing_trades, trades], ignore_index=True, copy=False
-                )
-
-    def get_trades(self) -> pd.DataFrame:
-        return (
-            self.user_data_["trades"] if "trades" in self.user_data_ else pd.DataFrame()
-        )
-
-    def cointegration_check(self) -> Optional[pd.DataFrame]:
-        print(f"***{self}*** STARTING....")
-        config = self.config_
-
-        curr_training_start_idx = 0
-
-        COINTEGRATION_DATA_COLUMNS = {
-            "tstamp": "datetime64[ns]",
-            "pair": "string",
-            "eg_pvalue": "float64",
-            "johansen_lr1": "float64",
-            "johansen_cvt": "float64",
-            "eg_is_cointegrated": "bool",
-            "johansen_is_cointegrated": "bool",
-        }
-        # Initialize trades DataFrame with proper dtypes to avoid concatenation warnings
-        result: pd.DataFrame = pd.DataFrame(
-            columns=[col for col in COINTEGRATION_DATA_COLUMNS.keys()]
-        )  # .astype(COINTEGRATION_DATA_COLUMNS)
-
-        training_minutes = config["training_minutes"]
-        while True:
-            print(curr_training_start_idx, end="\r")
-            self.get_datasets(
-                training_minutes=training_minutes,
-                training_start_index=curr_training_start_idx,
-                testing_size=1,
-            )
-
-            if len(self.training_df_) < training_minutes:
-                print(
-                    f"{self}: current offset={curr_training_start_idx}"
-                    f" * Training data length={len(self.training_df_)} < {training_minutes}"
-                    " * Not enough training data. Completing the job."
-                )
-                break
-            new_row = pd.Series(CointegrationData(self).to_dict())
-            result.loc[len(result)] = new_row
-            curr_training_start_idx += 1
-        return result
-
-    def 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 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 _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 __repr__(self) -> str:
-        return self.name()
-
-    def name(self) -> str:
-        return f"{self.symbol_a_} & {self.symbol_b_}"
-        # return f"{self.symbol_a_} & {self.symbol_b_}"
-
-    @abstractmethod
-    def predict(self) -> pd.DataFrame: ...
-
-    # @abstractmethod
-    # def predicted_df(self) -> Optional[pd.DataFrame]: ...

__DELETE__/lib/pt_trading/vecm_rolling_fit.py

@@ -1,122 +0,0 @@
-from typing import Any, Dict, Optional, cast
-
-import pandas as pd
-from pt_trading.results import BacktestResult
-from pt_trading.rolling_window_fit import RollingFit
-from pt_trading.trading_pair import TradingPair
-from statsmodels.tsa.vector_ar.vecm import VECM, VECMResults
-
-NanoPerMin = 1e9
-
-
-class VECMTradingPair(TradingPair):
-    vecm_fit_: Optional[VECMResults]
-    pair_predict_result_: Optional[pd.DataFrame]
-
-    def __init__(
-        self,
-        config: Dict[str, Any],
-        market_data: pd.DataFrame,
-        symbol_a: str,
-        symbol_b: str,
-    ):
-        super().__init__(config, market_data, symbol_a, symbol_b)
-        self.vecm_fit_ = None
-        self.pair_predict_result_ = None
-
-    def _train_pair(self) -> None:
-        self._fit_VECM()
-        assert self.vecm_fit_ is not None
-        diseq_series = self.training_df_[self.colnames()] @ self.vecm_fit_.beta
-        # print(diseq_series.shape)
-        self.training_mu_ = float(diseq_series[0].mean())
-        self.training_std_ = float(diseq_series[0].std())
-
-        self.training_df_["dis-equilibrium"] = (
-            self.training_df_[self.colnames()] @ self.vecm_fit_.beta
-        )
-        # Normalize the dis-equilibrium
-        self.training_df_["scaled_dis-equilibrium"] = (
-            diseq_series - self.training_mu_
-        ) / self.training_std_
-
-    def _fit_VECM(self) -> None:
-        assert self.training_df_ is not None
-        vecm_df = self.training_df_[self.colnames()].reset_index(drop=True)
-        vecm_model = VECM(vecm_df, coint_rank=1)
-        vecm_fit = vecm_model.fit()
-
-        assert vecm_fit is not None
-
-        # URGENT check beta and alpha
-
-        # Check if the model converged properly
-        if not hasattr(vecm_fit, "beta") or vecm_fit.beta is None:
-            print(f"{self}: VECM model failed to converge properly")
-
-        self.vecm_fit_ = vecm_fit
-        pass
-
-    def predict(self) -> pd.DataFrame:
-        self._train_pair()
-
-        assert self.testing_df_ is not None
-        assert self.vecm_fit_ is not None
-        predicted_prices = self.vecm_fit_.predict(steps=len(self.testing_df_))
-
-        # Convert prediction to a DataFrame for readability
-        predicted_df = pd.DataFrame(
-            predicted_prices, columns=pd.Index(self.colnames()), dtype=float
-        )
-
-        predicted_df = pd.merge(
-            self.testing_df_.reset_index(drop=True),
-            pd.DataFrame(
-                predicted_prices, columns=pd.Index(self.colnames()), dtype=float
-            ),
-            left_index=True,
-            right_index=True,
-            suffixes=("", "_pred"),
-        ).dropna()
-
-        predicted_df["disequilibrium"] = (
-            predicted_df[self.colnames()] @ self.vecm_fit_.beta
-        )
-
-        predicted_df["signed_scaled_disequilibrium"] = (
-            predicted_df["disequilibrium"] - self.training_mu_
-        ) / self.training_std_
-
-        predicted_df["scaled_disequilibrium"] = abs(
-            predicted_df["signed_scaled_disequilibrium"]
-        )
-
-        predicted_df = predicted_df.reset_index(drop=True)
-        if self.pair_predict_result_ is None:
-            self.pair_predict_result_ = predicted_df
-        else:
-            self.pair_predict_result_ = pd.concat(
-                [self.pair_predict_result_, predicted_df], ignore_index=True
-            )
-        # Reset index to ensure proper indexing
-        self.pair_predict_result_ = self.pair_predict_result_.reset_index(drop=True)
-        return self.pair_predict_result_
-
-
-class VECMRollingFit(RollingFit):
-    def __init__(self) -> None:
-        super().__init__()
-
-    def create_trading_pair(
-        self,
-        config: Dict,
-        market_data: pd.DataFrame,
-        symbol_a: str,
-        symbol_b: str,
-    ) -> TradingPair:
-        return VECMTradingPair(
-            config=config,
-            market_data=market_data,
-            symbol_a=symbol_a,
-            symbol_b=symbol_b,
-        )

__DELETE__/lib/pt_trading/z-score_rolling_fit.py

@@ -1,85 +0,0 @@
-from typing import Any, Dict, Optional, cast
-
-import pandas as pd
-from pt_trading.results import BacktestResult
-from pt_trading.rolling_window_fit import RollingFit
-from pt_trading.trading_pair import TradingPair
-import statsmodels.api as sm
-
-NanoPerMin = 1e9
-
-
-class ZScoreTradingPair(TradingPair):
-    zscore_model_: Optional[sm.regression.linear_model.RegressionResultsWrapper]
-    pair_predict_result_: Optional[pd.DataFrame]
-    zscore_df_: Optional[pd.DataFrame]
-
-    def __init__(
-        self,
-        config: Dict[str, Any],
-        market_data: pd.DataFrame,
-        symbol_a: str,
-        symbol_b: str,
-    ):
-        super().__init__(config, market_data, symbol_a, symbol_b)
-        self.zscore_model_ = None
-        self.pair_predict_result_ = None
-        self.zscore_df_ = None
-
-    def _fit_zscore(self) -> None:
-        assert self.training_df_ is not None
-        symbol_a_px_series = self.training_df_[self.colnames()].iloc[:, 0]
-        symbol_b_px_series = self.training_df_[self.colnames()].iloc[:, 1]
-
-        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]
-
-        # Calculate spread and Z-score
-        spread = symbol_a_px_series - hedge_ratio * symbol_b_px_series
-        self.zscore_df_ = (spread - spread.mean()) / spread.std()
-
-    def predict(self) -> pd.DataFrame:
-        self._fit_zscore()
-        assert self.zscore_df_ is not None
-        self.training_df_["dis-equilibrium"] = self.zscore_df_
-        self.training_df_["scaled_dis-equilibrium"] = abs(self.zscore_df_)
-
-        assert self.testing_df_ is not None
-        assert self.zscore_df_ is not None
-        predicted_df = self.testing_df_
-
-        predicted_df["disequilibrium"] = self.zscore_df_
-        predicted_df["signed_scaled_disequilibrium"] = self.zscore_df_
-        predicted_df["scaled_disequilibrium"] = abs(self.zscore_df_)
-
-        predicted_df = predicted_df.reset_index(drop=True)
-        if self.pair_predict_result_ is None:
-            self.pair_predict_result_ = predicted_df
-        else:
-            self.pair_predict_result_ = pd.concat(
-                [self.pair_predict_result_, predicted_df], ignore_index=True
-            )
-        # Reset index to ensure proper indexing
-        self.pair_predict_result_ = self.pair_predict_result_.reset_index(drop=True)
-        return self.pair_predict_result_.dropna()
-
-
-class ZScoreRollingFit(RollingFit):
-    def __init__(self) -> None:
-        super().__init__()
-
-    def create_trading_pair(
-        self, config: Dict, market_data: pd.DataFrame, symbol_a: str, symbol_b: str
-    ) -> TradingPair:
-        return ZScoreTradingPair(
-            config=config,
-            market_data=market_data,
-            symbol_a=symbol_a,
-            symbol_b=symbol_b,
-        )

__DELETE__/research/cointegration_test.py

@@ -1,126 +0,0 @@
-import argparse
-import glob
-import importlib
-import os
-from datetime import date, datetime
-from typing import Any, Dict, List, Optional
-
-import pandas as pd
-
-from tools.config import expand_filename, load_config
-from tools.data_loader import get_available_instruments_from_db
-from pt_trading.results import (
-    BacktestResult,
-    create_result_database,
-    store_config_in_database,
-    store_results_in_database,
-)
-from pt_trading.fit_method import PairsTradingFitMethod
-from pt_trading.trading_pair import TradingPair
-
-from research.research_tools import create_pairs, resolve_datafiles
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Run pairs trading backtest.")
-    parser.add_argument(
-        "--config", type=str, required=True, help="Path to the configuration file."
-    )
-    parser.add_argument(
-        "--datafile",
-        type=str,
-        required=False,
-        help="Market data file to process.",
-    )
-    parser.add_argument(
-        "--instruments",
-        type=str,
-        required=False,
-        help="Comma-separated list of instrument symbols (e.g., COIN,GBTC). If not provided, auto-detects from database.",
-    )
-    args = parser.parse_args()
-
-    config: Dict = load_config(args.config)
-
-    # Resolve data files (CLI takes priority over config)
-    datafile = resolve_datafiles(config, args.datafile)[0]
-
-    if not datafile:
-        print("No data files found to process.")
-        return
-
-    print(f"Found {datafile} data files to process:")
-
-    # # Create result database if needed
-    # if args.result_db.upper() != "NONE":
-    #     args.result_db = expand_filename(args.result_db)
-    #     create_result_database(args.result_db)
-
-    # # Initialize a dictionary to store all trade results
-    # all_results: Dict[str, Dict[str, Any]] = {}
-
-    # # Store configuration in database for reference
-    # if args.result_db.upper() != "NONE":
-    #     # Get list of all instruments for storage
-    #     all_instruments = []
-    #     for datafile in datafiles:
-    #         if args.instruments:
-    #             file_instruments = [
-    #                 inst.strip() for inst in args.instruments.split(",")
-    #             ]
-    #         else:
-    #             file_instruments = get_available_instruments_from_db(datafile, config)
-    #         all_instruments.extend(file_instruments)
-
-    #     # Remove duplicates while preserving order
-    #     unique_instruments = list(dict.fromkeys(all_instruments))
-
-    #     store_config_in_database(
-    #         db_path=args.result_db,
-    #         config_file_path=args.config,
-    #         config=config,
-    #         fit_method_class=fit_method_class_name,
-    #         datafiles=datafiles,
-    #         instruments=unique_instruments,
-    #     )
-
-    # Process each data file
-    stat_model_price = config["stat_model_price"]
-
-    print(f"\n====== Processing {os.path.basename(datafile)} ======")
-
-    # Determine instruments to use
-    if args.instruments:
-        # Use CLI-specified instruments
-        instruments = [inst.strip() for inst in args.instruments.split(",")]
-        print(f"Using CLI-specified instruments: {instruments}")
-    else:
-        # Auto-detect instruments from database
-        instruments = get_available_instruments_from_db(datafile, config)
-        print(f"Auto-detected instruments: {instruments}")
-
-    if not instruments:
-        print(f"No instruments found in {datafile}...")
-        return
-    # Process data for this file
-    try:
-        cointegration_data: pd.DataFrame = pd.DataFrame()
-        for pair in create_pairs(datafile, stat_model_price, config, instruments):
-            cointegration_data = pd.concat([cointegration_data, pair.cointegration_check()])
-
-        pd.set_option('display.width', 400)
-        pd.set_option('display.max_colwidth', None)
-        pd.set_option('display.max_columns', None)
-        with pd.option_context('display.max_rows', None, 'display.max_columns', None):
-            print(f"cointegration_data:\n{cointegration_data}")
-
-    except Exception as err:
-        print(f"Error processing {datafile}: {str(err)}")
-        import traceback
-
-        traceback.print_exc()
-
-
-
-if __name__ == "__main__":
-    main()

__DELETE__/research/pt_backtest.py

@@ -1,232 +0,0 @@
-import argparse
-import glob
-import importlib
-import os
-from datetime import date, datetime
-from typing import Any, Dict, List, Optional, Tuple
-
-import pandas as pd
-
-from research.research_tools import create_pairs
-from tools.config import expand_filename, load_config
-from pt_trading.results import (
-    BacktestResult,
-    create_result_database,
-    store_config_in_database,
-)
-from pt_trading.fit_method import PairsTradingFitMethod
-from pt_trading.trading_pair import TradingPair
-
-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
-
-
-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
-
-
-def run_backtest(
-    config: Dict,
-    datafiles: List[str],
-    fit_method: PairsTradingFitMethod,
-    instruments: List[Dict[str, str]],
-) -> BacktestResult:
-    """
-    Run backtest for all pairs using the specified instruments.
-    """
-    bt_result: BacktestResult = BacktestResult(config=config)
-    # if len(datafiles) < 2:
-    #     print(f"WARNING: insufficient data files: {datafiles}")
-    #     return bt_result
-
-    if not all([os.path.exists(datafile) for datafile in datafiles]):
-        print(f"WARNING: data file {datafiles} does not exist")
-        return bt_result
-
-    pairs_trades = []
-
-    pairs = create_pairs(
-        datafiles=datafiles,
-        fit_method=fit_method,
-        config=config,
-        instruments=instruments,
-    )
-    for pair in pairs:
-        single_pair_trades = fit_method.run_pair(pair=pair, bt_result=bt_result)
-        if single_pair_trades is not None and len(single_pair_trades) > 0:
-            pairs_trades.append(single_pair_trades)
-    print(f"pairs_trades:\n{pairs_trades}")
-    # Check if result_list has any data before concatenating
-    if len(pairs_trades) == 0:
-        print("No trading signals found for any pairs")
-        return bt_result
-
-    bt_result.collect_single_day_results(pairs_trades)
-    return bt_result
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Run pairs trading backtest.")
-    parser.add_argument(
-        "--config", type=str, required=True, help="Path to the configuration file."
-    )
-    parser.add_argument(
-        "--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)
-
-    # Dynamically instantiate fit method class
-    fit_method = PairsTradingFitMethod.create(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
-
-    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,
-                fit_method_class=config["fit_method_class"],
-                datafiles=datafiles,
-                instruments=instruments,
-            )
-            is_config_stored = True
-
-        # Process data for this file
-        try:
-            fit_method.reset()
-
-            bt_results = run_backtest(
-                config=config,
-                datafiles=md_datafiles,
-                fit_method=fit_method,
-                instruments=instruments,
-            )
-            
-            if bt_results.trades is None or len(bt_results.trades) == 0:
-                print(f"No trades found for {day}")
-                continue
-
-            # Store results with day name as key
-            filename = os.path.basename(day)
-            all_results[filename] = {
-                "trades": bt_results.trades.copy(),
-                "outstanding_positions": bt_results.outstanding_positions.copy(),
-            }
-
-            # Store results in database
-            if args.result_db.upper() != "NONE":
-                bt_results.calculate_returns(
-                    {
-                        filename: {
-                            "trades": bt_results.trades.copy(),
-                            "outstanding_positions": bt_results.outstanding_positions.copy(),
-                        }
-                    }
-                )
-                bt_results.store_results_in_database(db_path=args.result_db, day=day)
-
-            print(f"Successfully processed {filename}")
-
-        except Exception as err:
-            print(f"Error processing {day}: {str(err)}")
-            import traceback
-
-            traceback.print_exc()
-
-    # Calculate and print results using a new BacktestResult instance for aggregation
-    if all_results:
-        aggregate_bt_results = BacktestResult(config=config)
-        aggregate_bt_results.calculate_returns(all_results)
-        aggregate_bt_results.print_grand_totals()
-        aggregate_bt_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()

__DELETE__/strategy/pair_strategy.py

@@ -1,101 +0,0 @@
-import argparse
-import asyncio
-import glob
-import importlib
-import os
-from datetime import date, datetime
-from typing import Any, Dict, List, Optional
-
-import hjson
-import pandas as pd
-
-from tools.data_loader import get_available_instruments_from_db, load_market_data
-from pt_trading.results import (
-    BacktestResult,
-    create_result_database,
-    store_config_in_database,
-    store_results_in_database,
-)
-from pt_trading.fit_methods import PairsTradingFitMethod
-from pt_trading.trading_pair import TradingPair
-
-
-def run_strategy(
-    config: Dict,
-    datafile: str,
-    fit_method: PairsTradingFitMethod,
-    instruments: List[str],
-) -> BacktestResult:
-    """
-    Run backtest for all pairs using the specified instruments.
-    """
-    bt_result: BacktestResult = BacktestResult(config=config)
-
-    def _create_pairs(config: Dict, instruments: List[str]) -> List[TradingPair]:
-        nonlocal datafile
-        all_indexes = range(len(instruments))
-        unique_index_pairs = [(i, j) for i in all_indexes for j in all_indexes if i < j]
-        pairs = []
-
-        # Update config to use the specified instruments
-        config_copy = config.copy()
-        config_copy["instruments"] = instruments
-
-        market_data_df = load_market_data(
-            datafile=datafile,
-            exchange_id=config_copy["exchange_id"],
-            instruments=config_copy["instruments"],
-            instrument_id_pfx=config_copy["instrument_id_pfx"],
-            db_table_name=config_copy["db_table_name"],
-            trading_hours=config_copy["trading_hours"],
-        )
-
-        for a_index, b_index in unique_index_pairs:
-            pair = fit_method.create_trading_pair(
-                market_data=market_data_df,
-                symbol_a=instruments[a_index],
-                symbol_b=instruments[b_index],
-            )
-            pairs.append(pair)
-        return pairs
-
-    pairs_trades = []
-    for pair in _create_pairs(config, instruments):
-        single_pair_trades = fit_method.run_pair(
-            pair=pair, config=config, bt_result=bt_result
-        )
-        if single_pair_trades is not None and len(single_pair_trades) > 0:
-            pairs_trades.append(single_pair_trades)
-
-    # Check if result_list has any data before concatenating
-    if len(pairs_trades) == 0:
-        print("No trading signals found for any pairs")
-        return bt_result
-
-    result = pd.concat(pairs_trades, ignore_index=True)
-    result["time"] = pd.to_datetime(result["time"])
-    result = result.set_index("time").sort_index()
-
-    bt_result.collect_single_day_results(result)
-    return bt_result
-
-
-def main() -> None:
-    # Load config
-    # Subscribe to CVTT market data
-    # On snapshot (with historical data) - create trading strategy with market data dateframe
-    
-    async def on_message(message_type: MessageTypeT, subscr_id: SubscriptionIdT, message: Dict, instrument_id: str) -> None:
-        print(f"{message_type=} {subscr_id=} {instrument_id}")
-        if message_type == "md_aggregate":
-            aggr = message.get("md_aggregate", [])
-            print(f"[{aggr['tstamp'][:19]}] *** RLTM ***  {message}")
-        elif message_type == "historical_md_aggregate":
-            for aggr in message.get("historical_data", []):
-                print(f"[{aggr['tstamp'][:19]}] *** HIST *** {aggr}")
-        else:
-            print(f"Unknown message type: {message_type}")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

__SAV__/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 2026-02-09 (v0.0.9)
+- related to the changes made in *cvttpy_tools 1.4.7*

__SAV__/VERSION

@@ -0,0 +1 @@
+0.0.9

__SAV__/apps/pair_selector/pair_selector.py

@@ -0,0 +1,937 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import sqlite3
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Union
+
+from aiohttp import web
+import numpy as np
+import pandas as pd
+from statsmodels.tsa.stattools import adfuller, coint # type: ignore
+from statsmodels.tsa.vector_ar.vecm import coint_johansen  # type: ignore
+
+
+from cvttpy_tools.base.app import App
+from cvttpy_tools.base.base import NamedObject
+from cvttpy_tools.base.config import Config, CvttAppConfig
+from cvttpy_tools.base.logger import Log
+from cvttpy_tools.base.timeutils import NanoPerSec, SecPerHour, current_nanoseconds
+from cvttpy_tools.comm.web.rest_service import RestService
+
+from cvttpy_trading.trading.exchange_config import ExchangeAccounts
+from cvttpy_trading.trading.instrument import ExchangeInstrument
+from cvttpy_trading.trading.mkt_data.md_summary import MdTradesAggregate, MdSummary
+
+from pairs_trading.apps.pair_selector.renderer import HtmlRenderer
+from pairs_trading.lib.live.rest import RESTSender
+
+
+@dataclass
+class BacktestAggregate:
+    aggr_time_ns_: int
+    num_trades_: Optional[int]
+
+
+@dataclass
+class InstrumentQuality(NamedObject):
+    instrument_: ExchangeInstrument
+    record_count_: int
+    latest_tstamp_: Optional[pd.Timestamp]
+    status_: str
+    reason_: str
+
+
+@dataclass
+class PairStats(NamedObject):
+    pair_name_: str
+    instrument_a_: ExchangeInstrument
+    instrument_b_: ExchangeInstrument
+    pvalue_eg_: Optional[float]
+    pvalue_adf_: Optional[float]
+    pvalue_j_: Optional[float]
+    trace_stat_j_: Optional[float]
+    rank_eg_: int = 0
+    rank_adf_: int = 0
+    rank_j_: int = 0
+    composite_rank_: int = 0
+
+    def as_dict(self) -> Dict[str, Any]:
+        return {
+            "exchange_a": self.instrument_a_.exchange_id_,
+            "exchange_b": self.instrument_b_.exchange_id_,
+            "pair_name": self.pair_name_,
+            "instrument_a": self.instrument_a_.instrument_id(),
+            "instrument_b": self.instrument_b_.instrument_id(),
+            "pvalue_eg": self.pvalue_eg_,
+            "pvalue_adf": self.pvalue_adf_,
+            "pvalue_j": self.pvalue_j_,
+            "trace_stat_j": self.trace_stat_j_,
+            "rank_eg": self.rank_eg_,
+            "rank_adf": self.rank_adf_,
+            "rank_j": self.rank_j_,
+            "composite_rank": self.composite_rank_,
+        }
+
+
+def _extract_price_from_fields(
+    price_field: str,
+    inst: ExchangeInstrument,
+    open: Optional[float],
+    high: Optional[float],
+    low: Optional[float],
+    close: Optional[float],
+    vwap: Optional[float],
+) -> float:
+    field_map = {
+        "open": open,
+        "high": high,
+        "low": low,
+        "close": close,
+        "vwap": vwap,
+    }
+    raw = field_map.get(price_field, close)
+    if raw is None:
+        raw = 0.0
+    return inst.get_price(raw)
+
+
+class DataFetcher(NamedObject):
+    sender_: RESTSender
+    interval_sec_: int
+    history_depth_sec_: int
+
+    def __init__(
+        self,
+        base_url: str,
+        interval_sec: int,
+        history_depth_sec: int,
+    ) -> None:
+        self.sender_ = RESTSender(base_url=base_url)
+        self.interval_sec_ = interval_sec
+        self.history_depth_sec_ = history_depth_sec
+
+    def fetch(
+        self, exch_acct: str, inst: ExchangeInstrument
+    ) -> List[MdTradesAggregate]:
+        rqst_data = {
+            "exch_acct": exch_acct,
+            "instrument_id": inst.instrument_id(),
+            "interval_sec": self.interval_sec_,
+            "history_depth_sec": self.history_depth_sec_,
+        }
+        response = self.sender_.send_post(endpoint="md_summary", post_body=rqst_data)
+        if response.status_code not in (200, 201):
+            Log.error(
+                f"{self.fname()}: error {response.status_code} for {inst.details_short()}: {response.text}"
+            )
+            return []
+        mdsums: List[MdSummary] = MdSummary.from_REST_response(response=response)
+        return [
+            mdsum.create_md_trades_aggregate(
+                exch_acct=exch_acct, exch_inst=inst, interval_sec=self.interval_sec_
+            )
+            for mdsum in mdsums
+        ]
+
+
+AggregateLike = Union[MdTradesAggregate, BacktestAggregate]
+
+
+class QualityChecker(NamedObject):
+    interval_sec_: int
+
+    def __init__(self, interval_sec: int) -> None:
+        self.interval_sec_ = interval_sec
+
+    def evaluate(
+        self,
+        inst: ExchangeInstrument,
+        aggr: Sequence[AggregateLike],
+        now_ts: Optional[pd.Timestamp] = None,
+    ) -> InstrumentQuality:
+        if len(aggr) == 0:
+            return InstrumentQuality(
+                instrument_=inst,
+                record_count_=0,
+                latest_tstamp_=None,
+                status_="FAIL",
+                reason_="no records",
+            )
+
+        aggr_sorted = sorted(aggr, key=lambda a: a.aggr_time_ns_)
+
+        latest_ts = pd.to_datetime(aggr_sorted[-1].aggr_time_ns_, unit="ns", utc=True)
+        now_ts = now_ts or pd.Timestamp.utcnow()
+        recency_cutoff = now_ts - pd.Timedelta(seconds=2 * self.interval_sec_)
+        if latest_ts <= recency_cutoff:
+            return InstrumentQuality(
+                instrument_=inst,
+                record_count_=len(aggr_sorted),
+                latest_tstamp_=latest_ts,
+                status_="FAIL",
+                reason_=f"stale: latest {latest_ts} <= cutoff {recency_cutoff}",
+            )
+
+        gaps_ok, reason = self._check_gaps(aggr_sorted)
+        status = "PASS" if gaps_ok else "FAIL"
+        return InstrumentQuality(
+            instrument_=inst,
+            record_count_=len(aggr_sorted),
+            latest_tstamp_=latest_ts,
+            status_=status,
+            reason_=reason,
+        )
+
+    def _check_gaps(self, aggr: Sequence[AggregateLike]) -> Tuple[bool, str]:
+        NUM_TRADES_THRESHOLD = 50
+        if len(aggr) < 2:
+            return True, "ok"
+
+        interval_ns = self.interval_sec_ * NanoPerSec
+        for idx in range(1, len(aggr)):
+            prev = aggr[idx - 1]
+            curr = aggr[idx]
+            delta = curr.aggr_time_ns_ - prev.aggr_time_ns_
+            missing_intervals = int(delta // interval_ns) - 1
+            if missing_intervals <= 0:
+                continue
+
+            prev_nt = prev.num_trades_
+            next_nt = curr.num_trades_
+            estimate = self._approximate_num_trades(prev_nt, next_nt)
+            if estimate > NUM_TRADES_THRESHOLD:
+                return False, (
+                    f"gap of {missing_intervals} interval(s), est num_trades={estimate} > {NUM_TRADES_THRESHOLD}"
+                )
+        return True, "ok"
+
+    @staticmethod
+    def _approximate_num_trades(prev_nt: Optional[int], next_nt: Optional[int]) -> float:
+        if prev_nt is None and next_nt is None:
+            return 0.0
+        if prev_nt is None:
+            return float(next_nt or 0)
+        if next_nt is None:
+            return float(prev_nt)
+        return (prev_nt + next_nt) / 2.0
+
+
+class PairAnalyzer(NamedObject):
+    price_field_: str
+    interval_sec_: int
+
+    def __init__(self, price_field: str, interval_sec: int) -> None:
+        self.price_field_ = price_field
+        self.interval_sec_ = interval_sec
+
+    def analyze(
+        self, series: Dict[ExchangeInstrument, pd.DataFrame]
+    ) -> Dict[str, PairStats]:
+        instruments = list(series.keys())
+        results: Dict[str, PairStats] = {}
+        for i in range(len(instruments)):
+            for j in range(i + 1, len(instruments)):
+                inst_a, inst_b, pair_name = self._normalized_pair(
+                    instruments[i], instruments[j]
+                )
+                df_a = series[inst_a][["tstamp", "price"]].rename(
+                    columns={"price": "price_a"}
+                )
+                df_b = series[inst_b][["tstamp", "price"]].rename(
+                    columns={"price": "price_b"}
+                )
+                merged = pd.merge(df_a, df_b, on="tstamp", how="inner").sort_values(
+                    "tstamp"
+                )
+                # Log.info(f"{self.fname()}: analyzing {pair_name}")
+                stats = self._compute_stats(inst_a, inst_b, pair_name, merged)
+                if stats:
+                    results[pair_name] = stats
+        return self._rank(results)
+
+    def _compute_stats(
+        self,
+        inst_a: ExchangeInstrument,
+        inst_b: ExchangeInstrument,
+        pair_name: str,
+        merged: pd.DataFrame,
+    ) -> Optional[PairStats]:
+        if len(merged) < 2:
+            return None
+        px_a = merged["price_a"].astype(float)
+        px_b = merged["price_b"].astype(float)
+
+        std_a = float(px_a.std())
+        std_b = float(px_b.std())
+        if std_a == 0 or std_b == 0:
+            return None
+
+        z_a = (px_a - float(px_a.mean())) / std_a
+        z_b = (px_b - float(px_b.mean())) / std_b
+
+        p_eg: Optional[float]
+        p_adf: Optional[float]
+        p_j: Optional[float]
+        trace_stat: Optional[float]
+
+        try:
+            p_eg = float(coint(z_a, z_b)[1])
+        except Exception as exc:
+            Log.warning(
+                f"{self.fname()}: EG failed for {inst_a.details_short()}/{inst_b.details_short()}: {exc}"
+            )
+            p_eg = None
+
+        try:
+            spread = z_a - z_b
+            p_adf = float(adfuller(spread, maxlag=1, regression="c")[1])
+        except Exception as exc:
+            Log.warning(
+                f"{self.fname()}: ADF failed for {inst_a.details_short()}/{inst_b.details_short()}: {exc}"
+            )
+            p_adf = None
+
+        try:
+            data = np.column_stack([z_a, z_b])
+            res = coint_johansen(data, det_order=0, k_ar_diff=1)
+            trace_stat = float(res.lr1[0])
+            cv10, cv5, cv1 = res.cvt[0]
+            if trace_stat > cv1:
+                p_j = 0.01
+            elif trace_stat > cv5:
+                p_j = 0.05
+            elif trace_stat > cv10:
+                p_j = 0.10
+            else:
+                p_j = 1.0
+        except Exception as exc:
+            Log.warning(
+                f"{self.fname()}: Johansen failed for {inst_a.details_short()}/{inst_b.details_short()}: {exc}"
+            )
+            p_j = None
+            trace_stat = None
+
+        return PairStats(
+            pair_name_=pair_name,
+            instrument_a_=inst_a,
+            instrument_b_=inst_b,
+            pvalue_eg_=p_eg,
+            pvalue_adf_=p_adf,
+            pvalue_j_=p_j,
+            trace_stat_j_=trace_stat,
+        )
+
+    def _rank(self, results: Dict[str, PairStats]) -> Dict[str, PairStats]:
+        ranked = list(results.values())
+        self._assign_ranks(ranked, key=lambda r: r.pvalue_eg_, attr="rank_eg_")
+        self._assign_ranks(ranked, key=lambda r: r.pvalue_adf_, attr="rank_adf_")
+        self._assign_ranks(ranked, key=lambda r: r.pvalue_j_, attr="rank_j_")
+        for res in ranked:
+            res.composite_rank_ = res.rank_eg_ + res.rank_adf_ # + res.rank_j_
+        ranked.sort(key=lambda r: r.composite_rank_)
+        return {res.pair_name_: res for res in ranked}
+
+    @staticmethod
+    def _normalized_pair(
+        inst_a: ExchangeInstrument, inst_b: ExchangeInstrument
+    ) -> Tuple[ExchangeInstrument, ExchangeInstrument, str]:
+        inst_a_id = PairAnalyzer._pair_label(inst_a.instrument_id())
+        inst_b_id = PairAnalyzer._pair_label(inst_b.instrument_id())
+        if inst_a_id <= inst_b_id:
+            return inst_a, inst_b, f"{inst_a_id}<->{inst_b_id}"
+        return inst_b, inst_a, f"{inst_b_id}<->{inst_a_id}"
+
+    @staticmethod
+    def _pair_label(instrument_id: str) -> str:
+        if instrument_id.startswith("PAIR-"):
+            return instrument_id[len("PAIR-") :]
+        return instrument_id
+
+    @staticmethod
+    def _assign_ranks(results: List[PairStats], key, attr: str) -> None:
+        values = [key(r) for r in results]
+        sorted_vals = sorted([v for v in values if v is not None])
+        for res in results:
+            val = key(res)
+            if val is None:
+                setattr(res, attr, len(sorted_vals) + 1)
+                continue
+            rank = 1 + sum(1 for v in sorted_vals if v < val)
+            setattr(res, attr, rank)
+
+
+class PairSelectionEngine(NamedObject):
+    config_: object
+    instruments_: List[ExchangeInstrument]
+    price_field_: str
+    fetcher_: DataFetcher
+    quality_: QualityChecker
+    analyzer_: PairAnalyzer
+    interval_sec_: int
+    history_depth_sec_: int
+    data_quality_cache_: List[InstrumentQuality]
+    pair_results_cache_: Dict[str, PairStats]
+
+    def __init__(
+        self,
+        config: Config,
+        instruments: List[ExchangeInstrument],
+        price_field: str,
+    ) -> None:
+        self.config_ = config
+        self.instruments_ = instruments
+        self.price_field_ = price_field
+
+        interval_sec = int(config.get_value("interval_sec", 0))
+        history_depth_sec = int(config.get_value("history_depth_hours", 0)) * SecPerHour
+        base_url = config.get_value("cvtt_base_url", None)
+        assert interval_sec > 0, "interval_sec must be > 0"
+        assert history_depth_sec > 0, "history_depth_sec must be > 0"
+        assert base_url, "cvtt_base_url must be set"
+
+        self.fetcher_ = DataFetcher(
+            base_url=base_url,
+            interval_sec=interval_sec,
+            history_depth_sec=history_depth_sec,
+        )
+        self.quality_ = QualityChecker(interval_sec=interval_sec)
+        self.analyzer_ = PairAnalyzer(
+            price_field=price_field, interval_sec=interval_sec
+        )
+
+        self.interval_sec_ = interval_sec
+        self.history_depth_sec_ = history_depth_sec
+
+        self.data_quality_cache_ = []
+        self.pair_results_cache_ = {}
+
+    async def run_once(self) -> None:
+        quality_results: List[InstrumentQuality] = []
+        price_series: Dict[ExchangeInstrument, pd.DataFrame] = {}
+
+        for inst in self.instruments_:
+            exch_acct = inst.user_data_.get("exch_acct") or inst.exchange_id_
+            aggr = self.fetcher_.fetch(exch_acct=exch_acct, inst=inst)
+            q = self.quality_.evaluate(inst, aggr)
+            quality_results.append(q)
+            if q.status_ != "PASS":
+                continue
+            df = self._to_dataframe(aggr, inst)
+            if len(df) > 0:
+                price_series[inst] = df
+        self.data_quality_cache_ = quality_results
+        self.pair_results_cache_ = self.analyzer_.analyze(price_series)
+
+    def _to_dataframe(
+        self, aggr: List[MdTradesAggregate], inst: ExchangeInstrument
+    ) -> pd.DataFrame:
+        rows: List[Dict[str, Any]] = []
+        for item in aggr:
+            rows.append(
+                {
+                    "tstamp": pd.to_datetime(item.aggr_time_ns_, unit="ns", utc=True),
+                    "price": self._extract_price(item, inst),
+                    "num_trades": item.num_trades_,
+                }
+            )
+        df = pd.DataFrame(rows)
+        return df.sort_values("tstamp").reset_index(drop=True)
+
+    def _extract_price(
+        self, aggr: MdTradesAggregate, inst: ExchangeInstrument
+    ) -> float:
+        return _extract_price_from_fields(
+            price_field=self.price_field_,
+            inst=inst,
+            open=aggr.open_,
+            high=aggr.high_,
+            low=aggr.low_,
+            close=aggr.close_,
+            vwap=aggr.vwap_,
+        )
+
+    def sleep_seconds_until_next_cycle(self) -> float:
+        now_ns = current_nanoseconds()
+        interval_ns = self.interval_sec_ * NanoPerSec
+        next_boundary = (now_ns // interval_ns + 1) * interval_ns
+        return max(0.0, (next_boundary - now_ns) / NanoPerSec)
+
+    def quality_dicts(self) -> List[Dict[str, Any]]:
+        res: List[Dict[str, Any]] = []
+        for q in self.data_quality_cache_:
+            res.append(
+                {
+                    "instrument": q.instrument_.instrument_id(),
+                    "record_count": q.record_count_,
+                    "latest_tstamp": (
+                        q.latest_tstamp_.isoformat() if q.latest_tstamp_ else None
+                    ),
+                    "status": q.status_,
+                    "reason": q.reason_,
+                }
+            )
+        return res
+
+    def pair_dicts(self) -> Dict[str, Dict[str, Any]]:
+        return {
+            pair_name: stats.as_dict()
+            for pair_name, stats in self.pair_results_cache_.items()
+        }
+
+
+class PairSelectionBacktest(NamedObject):
+    config_: object
+    instruments_: List[ExchangeInstrument]
+    price_field_: str
+    input_db_: str
+    output_db_: str
+    interval_sec_: int
+    history_depth_hours_: int
+    quality_: QualityChecker
+    analyzer_: PairAnalyzer
+    inst_by_key_: Dict[Tuple[str, str], ExchangeInstrument]
+    inst_by_id_: Dict[str, Optional[ExchangeInstrument]]
+    ambiguous_ids_: Set[str]
+
+    def __init__(
+        self,
+        config: Config,
+        instruments: List[ExchangeInstrument],
+        price_field: str,
+        input_db: str,
+        output_db: str,
+    ) -> None:
+        self.config_ = config
+        self.instruments_ = instruments
+        self.price_field_ = price_field
+        self.input_db_ = input_db
+        self.output_db_ = output_db
+
+        interval_sec = int(config.get_value("interval_sec", 0))
+        if interval_sec <= 0:
+            Log.warning(
+                f"{self.fname()}: interval_sec not set; defaulting to 60 seconds"
+            )
+            interval_sec = 60
+        history_depth_hours = int(config.get_value("history_depth_hours", 0))
+        assert history_depth_hours > 0, "history_depth_hours must be > 0"
+
+        self.interval_sec_ = interval_sec
+        self.history_depth_hours_ = history_depth_hours
+        self.quality_ = QualityChecker(interval_sec=interval_sec)
+        self.analyzer_ = PairAnalyzer(
+            price_field=price_field, interval_sec=interval_sec
+        )
+
+        self.inst_by_key_ = {
+            (inst.exchange_id_, inst.instrument_id()): inst for inst in instruments
+        }
+        self.inst_by_id_ = {}
+        self.ambiguous_ids_ = set()
+        for inst in instruments:
+            inst_id = inst.instrument_id()
+            if inst_id in self.inst_by_id_:
+                existing = self.inst_by_id_[inst_id]
+                if existing is not None and existing.exchange_id_ != inst.exchange_id_:
+                    self.inst_by_id_[inst_id] = None
+                    self.ambiguous_ids_.add(inst_id)
+            elif inst_id not in self.ambiguous_ids_:
+                self.inst_by_id_[inst_id] = inst
+
+        if self.ambiguous_ids_:
+            Log.warning(
+                f"{self.fname()}: ambiguous instrument_id(s) without exchange_id: "
+                f"{sorted(self.ambiguous_ids_)}"
+            )
+
+    def run(self) -> None:
+        df = self._load_input_df()
+        if df.empty:
+            Log.warning(f"{self.fname()}: no rows in md_1min_bars")
+            return
+
+        df = self._filter_instruments(df)
+        if df.empty:
+            Log.warning(f"{self.fname()}: no rows after instrument filtering")
+            return
+
+        conn = self._init_output_db()
+        try:
+            self._run_backtest(df, conn)
+        finally:
+            conn.commit()
+            conn.close()
+
+    def _load_input_df(self) -> pd.DataFrame:
+        if not os.path.exists(self.input_db_):
+            raise FileNotFoundError(f"input_db not found: {self.input_db_}")
+        with sqlite3.connect(self.input_db_) as conn:
+            df = pd.read_sql_query(
+                """
+                SELECT
+                    tstamp,
+                    tstamp_ns,
+                    exchange_id,
+                    instrument_id,
+                    open,
+                    high,
+                    low,
+                    close,
+                    volume,
+                    vwap,
+                    num_trades
+                FROM md_1min_bars
+                """,
+                conn,
+            )
+        if df.empty:
+            return df
+
+        ts_ns = pd.to_datetime(df["tstamp_ns"], unit="ns", utc=True, errors="coerce")
+        ts_txt = pd.to_datetime(df["tstamp"], utc=True, errors="coerce")
+        df["tstamp"] = ts_ns.fillna(ts_txt)
+        df = df.dropna(subset=["tstamp", "instrument_id"]).copy()
+        df["exchange_id"] = df["exchange_id"].fillna("")
+        df["instrument_id"] = df["instrument_id"].astype(str)
+        df["tstamp_ns"] = df["tstamp"].astype("int64")
+        return df.sort_values("tstamp").reset_index(drop=True)
+
+    def _filter_instruments(self, df: pd.DataFrame) -> pd.DataFrame:
+        instrument_ids = {inst.instrument_id() for inst in self.instruments_}
+        df = df[df["instrument_id"].isin(instrument_ids)].copy()
+        if "exchange_id" in df.columns:
+            exchange_ids = {inst.exchange_id_ for inst in self.instruments_}
+            df = df[
+                (df["exchange_id"].isin(exchange_ids)) | (df["exchange_id"] == "")
+            ].copy()
+        return df
+
+    def _init_output_db(self) -> sqlite3.Connection:
+        if os.path.exists(self.output_db_):
+            os.remove(self.output_db_)
+        conn = sqlite3.connect(self.output_db_)
+        conn.execute(
+            """
+            CREATE TABLE pair_selection_history (
+                tstamp TEXT,
+                tstamp_ns INTEGER,
+                pair_name TEXT,
+                exchange_a TEXT,
+                instrument_a TEXT,
+                exchange_b TEXT,
+                instrument_b TEXT,
+                pvalue_eg REAL,
+                pvalue_adf REAL,
+                pvalue_j REAL,
+                trace_stat_j REAL,
+                rank_eg INTEGER,
+                rank_adf INTEGER,
+                rank_j INTEGER,
+                composite_rank REAL
+            )
+            """
+        )
+        conn.execute(
+            """
+            CREATE INDEX idx_pair_selection_history_pair_name
+            ON pair_selection_history (pair_name)
+            """
+        )
+        conn.execute(
+            """
+            CREATE UNIQUE INDEX idx_pair_selection_history_tstamp_pair
+            ON pair_selection_history (tstamp, pair_name)
+            """
+        )
+        conn.commit()
+        return conn
+
+    def _resolve_instrument(
+        self, exchange_id: str, instrument_id: str
+    ) -> Optional[ExchangeInstrument]:
+        if exchange_id:
+            inst = self.inst_by_key_.get((exchange_id, instrument_id))
+            if inst is not None:
+                return inst
+        inst = self.inst_by_id_.get(instrument_id)
+        if inst is None and instrument_id in self.ambiguous_ids_:
+            return None
+        return inst
+
+    def _build_day_series(
+        self, df_day: pd.DataFrame
+    ) -> Dict[ExchangeInstrument, pd.DataFrame]:
+        series: Dict[ExchangeInstrument, pd.DataFrame] = {}
+        group_cols = ["exchange_id", "instrument_id"]
+        for key, group in df_day.groupby(group_cols, dropna=False):
+            exchange_id, instrument_id = key
+            inst = self._resolve_instrument(str(exchange_id or ""), str(instrument_id))
+            if inst is None:
+                continue
+            df_inst = group.copy()
+            df_inst["price"] = [
+                _extract_price_from_fields(
+                    price_field=self.price_field_,
+                    inst=inst,
+                    open=float(row.open), #type: ignore
+                    high=float(row.high), #type: ignore
+                    low=float(row.low), #type: ignore
+                    close=float(row.close), #type: ignore
+                    vwap=float(row.vwap),#type: ignore
+                )
+                for row in df_inst.itertuples(index=False)
+            ]
+            df_inst = df_inst[["tstamp", "tstamp_ns", "price", "num_trades"]]
+            if inst in series:
+                series[inst] = pd.concat([series[inst], df_inst], ignore_index=True)
+            else:
+                series[inst] = df_inst
+        for inst in list(series.keys()):
+            series[inst] = series[inst].sort_values("tstamp").reset_index(drop=True)
+        return series
+
+    def _run_backtest(self, df: pd.DataFrame, conn: sqlite3.Connection) -> None:
+        window_minutes = self.history_depth_hours_ * 60
+        window_td = pd.Timedelta(minutes=window_minutes)
+        step_td = pd.Timedelta(seconds=self.interval_sec_)
+
+        df = df.copy()
+        df["day"] = df["tstamp"].dt.normalize()
+        days = sorted(df["day"].unique())
+        for day in days:
+            day_label = pd.Timestamp(day).date()
+            df_day = df[df["day"] == day]
+            t0 = df_day["tstamp"].min()
+            t_last = df_day["tstamp"].max()
+            if t_last - t0 < window_td:
+                Log.warning(
+                    f"{self.fname()}: skipping {day_label} (insufficient data)"
+                )
+                continue
+
+            day_series = self._build_day_series(df_day)
+            if len(day_series) < 2:
+                Log.warning(
+                    f"{self.fname()}: skipping {day_label} (insufficient instruments)"
+                )
+                continue
+
+            start = t0
+            expected_end = start + window_td
+            while expected_end <= t_last:
+                window_slices: Dict[ExchangeInstrument, pd.DataFrame] = {}
+                ts: Optional[pd.Timestamp] = None
+                for inst, df_inst in day_series.items():
+                    df_win = df_inst[
+                        (df_inst["tstamp"] >= start)
+                        & (df_inst["tstamp"] < expected_end)
+                    ]
+                    if df_win.empty:
+                        continue
+                    window_slices[inst] = df_win
+                    last_ts = df_win["tstamp"].iloc[-1]
+                    if ts is None or last_ts > ts:
+                        ts = last_ts
+
+                if window_slices and ts is not None:
+                    price_series: Dict[ExchangeInstrument, pd.DataFrame] = {}
+                    for inst, df_win in window_slices.items():
+                        aggr = self._to_backtest_aggregates(df_win)
+                        q = self.quality_.evaluate(
+                            inst=inst, aggr=aggr, now_ts=ts
+                        )
+                        if q.status_ != "PASS":
+                            continue
+                        price_series[inst] = df_win[["tstamp", "price"]]
+                    pair_results = self.analyzer_.analyze(price_series)
+                    Log.info(f"{self.fname()}: Saving Results for window ending {ts}")
+                    self._insert_results(conn, ts, pair_results)
+
+                start = start + step_td
+                expected_end = start + window_td
+
+    @staticmethod
+    def _to_backtest_aggregates(df_win: pd.DataFrame) -> List[BacktestAggregate]:
+        aggr: List[BacktestAggregate] = []
+        for tstamp_ns, num_trades in zip(df_win["tstamp_ns"], df_win["num_trades"]):
+            nt = None if pd.isna(num_trades) else int(num_trades)
+            aggr.append(
+                BacktestAggregate(aggr_time_ns_=int(tstamp_ns), num_trades_=nt)
+            )
+        return aggr
+
+    @staticmethod
+    def _insert_results(
+        conn: sqlite3.Connection,
+        ts: pd.Timestamp,
+        pair_results: Dict[str, PairStats],
+    ) -> None:
+        if not pair_results:
+            return
+        iso = ts.isoformat()
+        ns = int(ts.value)
+        rows = []
+        for pair_name in sorted(pair_results.keys()):
+            stats = pair_results[pair_name]
+            rows.append(
+                (
+                    iso,
+                    ns,
+                    pair_name,
+                    stats.instrument_a_.exchange_id_,
+                    stats.instrument_a_.instrument_id(),
+                    stats.instrument_b_.exchange_id_,
+                    stats.instrument_b_.instrument_id(),
+                    stats.pvalue_eg_,
+                    stats.pvalue_adf_,
+                    stats.pvalue_j_,
+                    stats.trace_stat_j_,
+                    stats.rank_eg_,
+                    stats.rank_adf_,
+                    stats.rank_j_,
+                    stats.composite_rank_,
+                )
+            )
+        conn.executemany(
+            """
+            INSERT INTO pair_selection_history (
+                tstamp,
+                tstamp_ns,
+                pair_name,
+                exchange_a,
+                instrument_a,
+                exchange_b,
+                instrument_b,
+                pvalue_eg,
+                pvalue_adf,
+                pvalue_j,
+                trace_stat_j,
+                rank_eg,
+                rank_adf,
+                rank_j,
+                composite_rank
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            rows,
+        )
+        conn.commit()
+
+
+
+class PairSelector(NamedObject):
+    instruments_: List[ExchangeInstrument]
+    engine_: PairSelectionEngine
+    rest_service_: Optional[RestService]
+    backtest_: Optional[PairSelectionBacktest]
+
+    def __init__(self) -> None:
+        App.instance().add_cmdline_arg("--oneshot", action="store_true", default=False)
+        App.instance().add_cmdline_arg("--backtest", action="store_true", default=False)
+        App.instance().add_cmdline_arg("--input_db", default=None)
+        App.instance().add_cmdline_arg("--output_db", default=None)
+        App.instance().add_call(App.Stage.Config, self._on_config())
+        App.instance().add_call(App.Stage.Run, self.run())
+
+    async def _on_config(self) -> None:
+        cfg = CvttAppConfig.instance()
+        self.instruments_ = self._load_instruments(cfg)
+        price_field = cfg.get_value("model/stat_model_price", "close")
+
+        self.backtest_ = None
+        self.rest_service_ = None
+        if App.instance().get_argument("backtest", False):
+            input_db = App.instance().get_argument("input_db", None)
+            output_db = App.instance().get_argument("output_db", None)
+            if not input_db or not output_db:
+                raise ValueError(
+                    "--input_db and --output_db are required when --backtest is set"
+                )
+            self.backtest_ = PairSelectionBacktest(
+                config=cfg,
+                instruments=self.instruments_,
+                price_field=price_field,
+                input_db=input_db,
+                output_db=output_db,
+            )
+            return
+
+        self.engine_ = PairSelectionEngine(
+            config=cfg,
+            instruments=self.instruments_,
+            price_field=price_field,
+        )
+
+        self.rest_service_ = RestService(config_key="/api/REST")
+        self.rest_service_.add_handler("GET", "/data_quality", self._on_data_quality)
+        self.rest_service_.add_handler(
+            "GET", "/pair_selection", self._on_pair_selection
+        )
+
+    def _load_instruments(self, cfg: CvttAppConfig) -> List[ExchangeInstrument]:
+        instruments_cfg = cfg.get_value("instruments", [])
+        instruments: List[ExchangeInstrument] = []
+        assert len(instruments_cfg) >= 2, "at least two instruments required"
+        for item in instruments_cfg:
+            if isinstance(item, str):
+                parts = item.split(":", 1)
+                if len(parts) != 2:
+                    raise ValueError(f"invalid instrument format: {item}")
+                exch_acct, instrument_id = parts
+            elif isinstance(item, dict):
+                exch_acct = item.get("exch_acct", "")
+                instrument_id = item.get("instrument_id", "")
+                if not exch_acct or not instrument_id:
+                    raise ValueError(f"invalid instrument config: {item}")
+            else:
+                raise ValueError(f"unsupported instrument entry: {item}")
+
+            exch_inst = ExchangeAccounts.instance().get_exchange_instrument(
+                exch_acct=exch_acct, instrument_id=instrument_id
+            )
+            assert (
+                exch_inst is not None
+            ), f"no ExchangeInstrument for {exch_acct}:{instrument_id}"
+            exch_inst.user_data_["exch_acct"] = exch_acct
+            instruments.append(exch_inst)
+        return instruments
+
+    async def run(self) -> None:
+        if App.instance().get_argument("backtest", False):
+            if self.backtest_ is None:
+                raise RuntimeError("backtest runner not initialized")
+            self.backtest_.run()
+            return
+        oneshot = App.instance().get_argument("oneshot", False)
+        while True:
+            await self.engine_.run_once()
+            if oneshot:
+                break
+            sleep_for = self.engine_.sleep_seconds_until_next_cycle()
+            await asyncio.sleep(sleep_for)
+
+    async def _on_data_quality(self, request: web.Request) -> web.Response:
+        fmt = request.query.get("format", "html").lower()
+        quality = self.engine_.quality_dicts()
+        if fmt == "json":
+            return web.json_response(quality)
+        return web.Response(
+            text=HtmlRenderer.render_data_quality(quality), content_type="text/html"
+        )
+
+    async def _on_pair_selection(self, request: web.Request) -> web.Response:
+        fmt = request.query.get("format", "html").lower()
+        pairs = self.engine_.pair_dicts()
+        if fmt == "json":
+            return web.json_response(pairs)
+        return web.Response(
+            text=HtmlRenderer.render_pairs(pairs), content_type="text/html"
+        )
+
+
+if __name__ == "__main__":
+    App()
+    CvttAppConfig()
+    PairSelector()
+    App.instance().run()

__SAV__/apps/pair_selector/renderer.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+
+from cvttpy_tools.base.app import App
+from cvttpy_tools.base.base import NamedObject
+from cvttpy_tools.base.config import CvttAppConfig
+
+
+class HtmlRenderer(NamedObject):
+    def __init__(self) -> None:
+        pass
+
+    @staticmethod
+    def render_data_quality(quality: List[Dict[str, Any]]) -> str:
+        rows = "".join(
+            f"<tr>"
+            f"<td>{q.get('instrument','')}</td>"
+            f"<td>{q.get('record_count','')}</td>"
+            f"<td>{q.get('latest_tstamp','')}</td>"
+            f"<td>{q.get('status','')}</td>"
+            f"<td>{q.get('reason','')}</td>"
+            f"</tr>"
+            for q in sorted(quality, key=lambda x: str(x.get("instrument", "")))
+        )
+        return f"""
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset='utf-8'/>
+    <title>Data Quality</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; margin: 20px; }}
+        table {{ border-collapse: collapse; width: 100%; }}
+        th, td {{ border: 1px solid #ccc; padding: 8px; text-align: left; }}
+        th {{ background: #f2f2f2; }}
+    </style>
+</head>
+<body>
+    <h2>Data Quality</h2>
+    <table>
+        <thead>
+            <tr><th>Instrument</th><th>Records</th><th>Latest</th><th>Status</th><th>Reason</th></tr>
+        </thead>
+        <tbody>{rows}</tbody>
+    </table>
+</body>
+</html>
+"""
+
+    @staticmethod
+    def render_pairs(pairs: Dict[str, Dict[str, Any]]) -> str:
+        if not pairs:
+            body = "<p>No pairs available. Check data quality and try again.</p>"
+        else:
+            body_rows = []
+            for pair_name, p in pairs.items():
+                body_rows.append(
+                    "<tr>"
+                    f"<td>{pair_name}</td>"
+                    f"<td data-value='{p.get('rank_eg',0)}'>{p.get('rank_eg','')}</td>"
+                    f"<td data-value='{p.get('rank_adf',0)}'>{p.get('rank_adf','')}</td>"
+                    f"<td data-value='{p.get('rank_j',0)}'>{p.get('rank_j','')}</td>"
+                    f"<td data-value='{p.get('pvalue_eg','')}'>{p.get('pvalue_eg','')}</td>"
+                    f"<td data-value='{p.get('pvalue_adf','')}'>{p.get('pvalue_adf','')}</td>"
+                    f"<td data-value='{p.get('pvalue_j','')}'>{p.get('pvalue_j','')}</td>"
+                    "</tr>"
+                )
+            body = "\n".join(body_rows)
+
+        return f"""
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset='utf-8'/>
+    <title>Pair Selection</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; margin: 20px; }}
+        table {{ border-collapse: collapse; width: 100%; }}
+        th, td {{ border: 1px solid #ccc; padding: 8px; text-align: left; }}
+        th.sortable {{ cursor: pointer; background: #f2f2f2; }}
+    </style>
+</head>
+<body>
+    <h2>Pair Selection</h2>
+    <table id="pairs-table">
+        <thead>
+            <tr>
+                <th>Pair</th>
+                <th class="sortable" data-type="num">Rank-EG</th>
+                <th class="sortable" data-type="num">Rank-ADF</th>
+                <th class="sortable" data-type="num">Rank-J</th>
+                <th>EG p-value</th>
+                <th>ADF p-value</th>
+                <th>Johansen pseudo p</th>
+            </tr>
+        </thead>
+        <tbody>
+            {body}
+        </tbody>
+    </table>
+    <script>
+    (function() {{
+        const table = document.getElementById('pairs-table');
+        if (!table) return;
+        const getValue = (cell) => {{
+            const val = cell.getAttribute('data-value');
+            const num = parseFloat(val);
+            return isNaN(num) ? val : num;
+        }};
+        const toggleSort = (index, isNumeric) => {{
+            const tbody = table.querySelector('tbody');
+            const rows = Array.from(tbody.querySelectorAll('tr'));
+            const th = table.querySelectorAll('th')[index];
+            const dir = th.getAttribute('data-dir') === 'asc' ? 'desc' : 'asc';
+            th.setAttribute('data-dir', dir);
+            rows.sort((a, b) => {{
+                const va = getValue(a.children[index]);
+                const vb = getValue(b.children[index]);
+                if (isNumeric && !isNaN(va) && !isNaN(vb)) {{
+                    return dir === 'asc' ? va - vb : vb - va;
+                }}
+                return dir === 'asc'
+                    ? String(va).localeCompare(String(vb))
+                    : String(vb).localeCompare(String(va));
+            }});
+            tbody.innerHTML = '';
+            rows.forEach(r => tbody.appendChild(r));
+        }};
+        table.querySelectorAll('th.sortable').forEach((th, idx) => {{
+            th.addEventListener('click', () => toggleSort(idx, th.dataset.type === 'num'));
+        }});
+    }})();
+    </script>
+</body>
+</html>
+"""

__SAV__/apps/pair_trader.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Callable, Coroutine, Dict, List
+import aiohttp.web as web
+
+from cvttpy_tools.base.app import App
+from cvttpy_tools.base.config import Config
+from cvttpy_tools.base.base import NamedObject
+from cvttpy_tools.base.config import CvttAppConfig
+from cvttpy_tools.base.logger import Log
+from cvttpy_tools.settings.cvtt_types import BookIdT
+from cvttpy_tools.comm.web.rest_service import RestService
+
+# ---
+from cvttpy_trading.trading.instrument import ExchangeInstrument
+from cvttpy_trading.trading.mkt_data.md_summary import MdTradesAggregate
+from cvttpy_trading.trading.exchange_config import ExchangeAccounts
+# ---
+from pairs_trading.lib.live.mkt_data_client import CvttRestMktDataClient
+
+'''
+config http://cloud16.cvtt.vpn/apps/pairs_trading
+'''
+
+HistMdCbT = Callable[[List[MdTradesAggregate]], Coroutine]
+UpdateMdCbT = Callable[[MdTradesAggregate], Coroutine]
+
+class PairTrader(NamedObject):
+    config_: CvttAppConfig
+    instruments_: List[ExchangeInstrument]
+    book_id_: BookIdT
+
+    live_strategy_: "PtLiveStrategy" #type: ignore
+    ti_sender_: "TradingInstructionsSender" #type: ignore
+    pricer_client_: CvttRestMktDataClient
+    rest_service_: RestService
+    
+    latest_history_: Dict[ExchangeInstrument, List[MdTradesAggregate]]
+    
+    def __init__(self) -> None:
+        self.instruments_ = []
+        self.latest_history_ = {}
+        
+        App.instance().add_cmdline_arg(
+            "--instrument_A",
+            type=str,
+            required=True,
+            help=(
+                " Instrument A in pair (e.g., COINBASE_AT:PAIR-BTC-USD)"
+            ),
+        )
+        App.instance().add_cmdline_arg(
+            "--instrument_B",
+            type=str,
+            required=True,
+            help=(
+                " Instrument B in pair (e.g., COINBASE_AT:PAIR-ETH-USD)"
+            ),
+        )
+
+        App.instance().add_cmdline_arg(
+            "--book_id",
+            type=str,
+            required=True,
+            help="Book ID"
+        )
+        App.instance().add_call(App.Stage.Config, self._on_config())
+        App.instance().add_call(App.Stage.Run, self.run())
+        
+    async def _on_config(self) -> None:
+        self.config_ = CvttAppConfig.instance()
+        self.book_id_ = App.instance().get_argument(name="book_id")
+        
+        # ------- PARSE INSTRUMENTS -------
+        instr_list: List[str] = []
+        instr_str = App.instance().get_argument("instrument_A", "")
+        assert instr_str != "", "Missing insrument A" 
+        instr_list.append(instr_str)
+        instr_str = App.instance().get_argument("instrument_B", "")
+        assert instr_str != "", "Missing insrument B" 
+        instr_list.append(instr_str)
+ 
+        for instr in instr_list:
+            instr_parts = instr.split(":")
+            if len(instr_parts) != 2:
+                raise ValueError(f"Invalid pair format: {instr}")   
+            exch_acct = instr_parts[0]
+            instrument_id = instr_parts[1]
+            exch_inst = ExchangeAccounts.instance().get_exchange_instrument(exch_acct=exch_acct, instrument_id=instrument_id)
+            assert exch_inst is not None, f"No ExchangeInstrument for {instr}"
+            exch_inst.user_data_["exch_acct"] = exch_acct
+            self.instruments_.append(exch_inst)
+
+        Log.info(f"{self.fname()} Instruments: {self.instruments_[0].details_short()} <==> {self.instruments_[1].details_short()}")
+        
+        # ------- CREATE STRATEGY -------
+        from pairs_trading.lib.pt_strategy.live.live_strategy import PtLiveStrategy
+        strategy_config = CvttAppConfig.instance() #self.config_.get_subconfig("strategy_config", Config({}))
+        self.live_strategy_ = PtLiveStrategy(
+            config=strategy_config,
+            pairs_trader=self,
+        )
+        Log.info(f"{self.fname()} Strategy created: {self.live_strategy_}")  
+        model_name = self.config_.get_value("model/name", "?model/name?")
+        self.config_.set_value("strategy_id", f"{self.live_strategy_.__class__.__name__}:{model_name}")
+        
+        # # ------- CREATE PRICER CLIENT -------
+        self.pricer_client_ = CvttRestMktDataClient(config=self.config_)
+        Log.info(f"{self.fname()} MD client created: {self.pricer_client_}")  
+        
+        # ------- CREATE TRADER CLIENT -------
+        from pairs_trading.lib.live.ti_sender import TradingInstructionsSender
+        self.ti_sender_ = TradingInstructionsSender(config=self.config_, pairs_trader=self)
+        Log.info(f"{self.fname()} TI sender created: {self.ti_sender_}")
+
+        # # ------- CREATE REST SERVER -------
+        self.rest_service_ = RestService(
+            config_key=f"/api/REST"
+        )
+        
+        # --- Strategy Handlers
+        self.rest_service_.add_handler(
+            method="POST",
+            url="/api/strategy",
+            handler=self._on_api_request,
+        )
+        
+    async def subscribe_md(self) -> None:
+        from functools import partial
+        for exch_inst in self.instruments_:
+            exch_acct = exch_inst.user_data_.get("exch_acct", "?exch_acct?")
+            instrument_id = exch_inst.instrument_id()
+            
+            await self.pricer_client_.add_subscription(
+                exch_acct=exch_acct,
+                instrument_id=instrument_id,
+                interval_sec=self.live_strategy_.interval_sec(),
+                history_depth_sec=self.live_strategy_.history_depth_sec(),
+                callback=partial(self._on_md_summary, exch_inst=exch_inst)
+            )
+
+    async def _on_md_summary(self, history: List[MdTradesAggregate], exch_inst: ExchangeInstrument) -> None:
+        Log.info(f"{self.fname()}: got {exch_inst.details_short()} data")
+        self.latest_history_[exch_inst] = history
+        if len(self.latest_history_) == 2:
+            from itertools import chain
+            all_aggrs = sorted(list(chain.from_iterable(self.latest_history_.values())), key=lambda X: X.aggr_time_ns_)
+
+            await self.live_strategy_.on_mkt_data_hist_snapshot(hist_aggr=all_aggrs)
+            self.latest_history_ = {}
+
+    async def _on_api_request(self, request: web.Request) -> web.Response:
+        # TODO choose pair
+        # TODO confirm chosen pair (after selection is implemented)
+        return web.Response() # TODO  API request handler implementation
+    
+    
+    async def run(self) -> None:
+        Log.info(f"{self.fname()} ...")
+        while True:
+            await asyncio.sleep(0.1)
+        pass
+
+if __name__ == "__main__":
+    App()
+    CvttAppConfig()
+    PairTrader()
+    App.instance().run()

__SAV__/build-dist.sh

@@ -0,0 +1,186 @@
+#!/usr/bin/env bash
+
+# ---------------- Settings
+
+repo=git@cloud21.cvtt.vpn:/works/git/cvtt2/research/pairs_trading.git
+
+dist_root=/home/cvttdist/software/cvtt2
+dist_user=cvttdist
+dist_host="cloud21.cvtt.vpn"
+dist_ssh_port="22"
+
+dist_locations="cloud21.cvtt.vpn:22 hs01.cvtt.vpn:22"
+version_file="VERSION"
+
+prj=pairs_trading
+brnch=master
+interactive=N
+
+# ---------------- Settings
+
+# ---------------- cmdline
+
+usage() {
+  echo "Usage: $0 [-b <branch (master)> -i (interactive)"
+  exit 1
+}
+
+while getopts "b:i" opt; do
+  case ${opt} in
+    b )
+      brnch=$OPTARG
+      ;;
+    i )
+      interactive=Y
+      ;;
+    \? )
+      echo "Invalid option: -$OPTARG" >&2
+      usage
+      ;;
+    : )
+      echo "Option -$OPTARG requires an argument." >&2
+      usage
+      ;;
+  esac
+done
+# ---------------- cmdline
+
+confirm() {
+    if [ "${interactive}" == "Y" ]; then
+        echo "--------------------------------"
+        echo -n "Press <Enter> to continue" && read
+    fi
+}
+
+
+if [ "${interactive}" == "Y" ]; then
+    echo -n "Enter project [${prj}]: "
+    read project
+    if [ "${project}" == "" ]
+    then
+        project=${prj}
+    fi
+else
+    project=${prj}
+fi
+
+# repo=${git_repo_arr[${project}]}
+if [ -z ${repo} ]; then
+    echo "ERROR: Project repository for ${project} not found"
+    exit -1
+fi
+echo "Project repo: ${repo}"
+
+if [ "${interactive}" == "Y" ]; then
+    echo -n "Enter branch to build release from [${brnch}]: "
+    read branch
+    if [ "${branch}" == "" ]
+    then
+        branch=${brnch}
+    fi
+else
+    branch=${brnch}
+fi
+
+tmp_dir=$(mktemp -d)
+function cleanup {
+    cd ${HOME}
+    rm -rf ${tmp_dir}
+}
+trap cleanup EXIT
+
+
+prj_dir="${tmp_dir}/${prj}"
+
+cmd_arr=()
+Cmd="git clone ${repo} ${prj_dir}"
+cmd_arr+=("${Cmd}")
+
+Cmd="cd ${prj_dir}"
+cmd_arr+=("${Cmd}")
+
+if [ "${interactive}" == "Y" ]; then
+    echo "------------------------------------"
+    echo "The following commands will execute:"
+    echo "------------------------------------"
+    for cmd in "${cmd_arr[@]}"
+    do
+        echo ${cmd}
+    done
+fi
+
+confirm
+
+for cmd in "${cmd_arr[@]}"
+do
+    echo ${cmd} && eval ${cmd}
+done
+
+Cmd="git checkout ${branch}"
+echo ${Cmd} && eval ${Cmd}
+if [ "${?}" != "0" ]; then
+    echo "ERROR: Branch ${branch} is not found"
+    cd ${HOME} && rm -rf ${tmp_dir}
+    exit -1
+fi
+
+
+release_version=$(cat ${version_file} | awk -F',' '{print $1}')
+whats_new=$(cat ${version_file} | awk -F',' '{print $2}')
+
+
+echo "--------------------------------"
+echo "Version file: ${version_file}"
+echo "Release version: ${release_version}"
+
+confirm
+
+version_tag="v${release_version}"
+if [ "$(git tag -l "${version_tag}")" != "" ]; then
+    version_tag="${version_tag}.$(date +%Y%m%d_%H%M)"
+fi
+version_comment="'${version_tag} ${project} ${branch} $(date +%Y-%m-%d)\n${whats_new}'"
+
+cmd_arr=()
+Cmd="git tag -a ${version_tag} -m ${version_comment}"
+cmd_arr+=("${Cmd}")
+
+Cmd="git push origin --tags"
+cmd_arr+=("${Cmd}")
+
+Cmd="rm -rf .git"
+cmd_arr+=("${Cmd}")
+
+SourceLoc=../${project}
+
+dist_path="${dist_root}/${project}/${release_version}"
+
+for dist_loc in ${dist_locations}; do
+    dhp=(${dist_loc//:/ })
+    dist_host=${dhp[0]}
+    dist_port=${dhp[1]}
+    Cmd="rsync -avzh"
+    Cmd="${Cmd} --rsync-path=\"mkdir -p ${dist_path}"
+    Cmd="${Cmd} && rsync\" -e \"ssh -p ${dist_ssh_port}\""
+    Cmd="${Cmd} $SourceLoc ${dist_user}@${dist_host}:${dist_path}/"
+    cmd_arr+=("${Cmd}")
+done
+
+if [ "${interactive}" == "Y" ]; then
+    echo "------------------------------------"
+    echo "The following commands will execute:"
+    echo "------------------------------------"
+    for cmd in "${cmd_arr[@]}"
+    do
+        echo ${cmd}
+    done
+fi
+
+confirm
+
+for cmd in "${cmd_arr[@]}"
+do
+    pwd && echo ${cmd} && eval ${cmd}
+done
+
+echo "$0 Done ${project} ${release_version}"

__SAV__/configuration/backtest.cfg

@@ -1,4 +1,11 @@
 {
+    "refdata": {
+        "assets": @inc=http://@env{CONFIG_SERVICE}/refdata/assets
+        , "instruments": @inc=http://@env{CONFIG_SERVICE}/refdata/instruments
+        , "exchange_instruments": @inc=http://@env{CONFIG_SERVICE}/refdata/exchange_instruments
+        , "dynamic_instrument_exchanges": ["ALPACA"]
+        , "exchanges": @inc=http://@env{CONFIG_SERVICE}/refdata/exchanges
+    }, 
     "market_data_loading": {
         "CRYPTO": {
             "data_directory": "./data/crypto",
@@ -11,25 +18,17 @@
             "instrument_id_pfx": "STOCK-",
         }
     },
-
     # ====== Funding ======
     "funding_per_pair": 2000.0,
-    # ====== Trading Parameters ======
+
-    "stat_model_price": "close",
+    # ====== Model =======
+    "model": @inc=http://@env{CONFIG_SERVICE}/apps/common/models/@env{MODEL_CONFIG} 
+
+    # ====== Trading ======= 
     "execution_price": {
         "column": "vwap",
         "shift": 1,
     },
-    "dis-equilibrium_open_trshld": 1.75,
-    "dis-equilibrium_close_trshld": 0.9,
-    "model_class": "pt_strategy.models.OLSModel",
-
-    "training_size": 120,
-    "model_data_policy_class": "pt_strategy.model_data_policy.RollingWindowDataPolicy",
-    # "model_data_policy_class": "pt_strategy.model_data_policy.OptimizedWindowDataPolicy",
-    # "min_training_size": 60,
-    # "max_training_size": 150,
-
     # ====== Stop Conditions ======
     "stop_close_conditions": {
         "profit": 2.0,

__SAV__/configuration/pair_trader.cfg

@@ -1,5 +1,5 @@
 {
-    "strategy_config": @inc=file:///home/oleg/develop/pairs_trading/configuration/ols.cfg
+    "strategy_config": @inc=file:///home/oleg/develop/pairs_trading/configuration/vecm-opt.cfg
     "pricer_config": {
         "pricer_url": "ws://localhost:12346/ws",
         "history_depth_sec": 86400 #"60*60*24",  # use simpleeval

__SAV__/configuration/vecm-opt.cfg

@@ -0,0 +1,56 @@
+{
+    # "refdata": {
+    #     "assets": @inc=http://@env{CONFIG_SERVICE}/refdata/assets
+    #     , "instruments": @inc=http://@env{CONFIG_SERVICE}/refdata/instruments
+    #     , "exchange_instruments": @inc=http://@env{CONFIG_SERVICE}/refdata/exchange_instruments
+    #     , "dynamic_instrument_exchanges": ["ALPACA"]
+    #     , "exchanges": @inc=http://@env{CONFIG_SERVICE}/refdata/exchanges
+    # }, 
+    # "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", # "vwap"
+    "execution_price": {
+        "column": "vwap",
+        "shift": 1,
+    },
+    "dis-equilibrium_open_trshld": 1.75,
+    "dis-equilibrium_close_trshld": 1.0,
+
+    "model_class": "pairs_trading.lib.pt_strategy.models.VECMModel",
+
+    # "training_size": 120,
+    # "model_data_policy_class": "pairs_trading.lib.pt_strategy.model_data_policy.RollingWindowDataPolicy",
+    "model_data_policy_class": "pairs_trading.lib.pt_strategy.model_data_policy.ADFOptimizedWndDataPolicy",
+    "min_training_size": 60,
+    "max_training_size": 150,
+
+    # # ====== 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",
+    # }
+}

__SAV__/lib/live/mkt_data_client.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Dict, Any, List, Optional, Set
+
+import requests
+
+from cvttpy_tools.base.base import NamedObject
+from cvttpy_tools.base.logger import Log
+from cvttpy_tools.base.config import Config
+from cvttpy_tools.base.timer import Timer
+from cvttpy_tools.base.timeutils import NanosT, current_seconds
+from cvttpy_tools.settings.cvtt_types import InstrumentIdT, IntervalSecT
+# ---
+from cvttpy_trading.trading.instrument import ExchangeInstrument
+from cvttpy_trading.trading.accounting.exch_account import ExchangeAccountNameT
+from cvttpy_trading.trading.mkt_data.md_summary import MdTradesAggregate, MdSummary, MdSummaryCallbackT
+from cvttpy_trading.trading.exchange_config import ExchangeAccounts
+# ---
+from pairs_trading.lib.live.rest import RESTSender
+
+
+# class MdSummary(HistMdBar):
+#     def __init__(
+#         self,
+#         ts_ns: int,
+#         open: float,
+#         high: float,
+#         low: float,
+#         close: float,
+#         volume: float,
+#         vwap: float,
+#         num_trades: int,
+#     ):
+#         super().__init__(ts=ts_ns)
+#         self.open_ = open
+#         self.high_ = high
+#         self.low_ = low
+#         self.close_ = close
+#         self.volume_ = volume
+#         self.vwap_ = vwap
+#         self.num_trades_ = num_trades
+
+#     @classmethod
+#     def from_REST_response(cls, response: requests.Response) -> List[MdSummary]:
+#         res: List[MdSummary] = []
+#         jresp = response.json()
+#         hist_data = jresp.get("historical_data", [])
+#         for hd in hist_data:
+#             res.append(
+#                 MdSummary(
+#                     ts_ns=hd["time_ns"],
+#                     open=hd["open"],
+#                     high=hd["high"],
+#                     low=hd["low"],
+#                     close=hd["close"],
+#                     volume=hd["volume"],
+#                     vwap=hd["vwap"],
+#                     num_trades=hd["num_trades"],
+#                 )
+#             )
+#         return res
+
+#     def create_md_trades_aggregate(
+#         self,
+#         exch_acct: ExchangeAccountNameT,
+#         exch_inst: ExchangeInstrument,
+#         interval_sec: IntervalSecT,
+#     ) -> MdTradesAggregate:
+#         res = MdTradesAggregate(
+#             exch_acct=exch_acct,
+#             exch_inst=exch_inst,
+#             interval_ns=interval_sec * NanoPerSec,
+#         )
+#         res.set(mdbar=self)
+#         return res
+
+
+# MdSummaryCallbackT = Callable[[List[MdTradesAggregate]], Coroutine]
+
+
+class MdSummaryCollector(NamedObject):
+    sender_: RESTSender
+    exch_acct_: ExchangeAccountNameT
+    exch_inst_: ExchangeInstrument
+    interval_sec_: IntervalSecT
+    history_depth_sec_: IntervalSecT
+
+    history_: List[MdTradesAggregate]
+
+    callbacks_: List[MdSummaryCallbackT]
+    timer_: Optional[Timer]
+
+    def __init__(
+        self,
+        sender: RESTSender,
+        exch_acct: ExchangeAccountNameT,
+        instrument_id: InstrumentIdT,
+        interval_sec: IntervalSecT,
+        history_depth_sec: IntervalSecT,
+    ) -> None:
+        self.sender_ = sender
+        self.exch_acct_ = exch_acct
+
+        exch_inst = ExchangeAccounts.instance().get_exchange_instrument(
+            exch_acct=exch_acct, instrument_id=instrument_id
+        )
+        assert exch_inst is not None, f"Unable to find Exchange instrument for {exch_acct}/{instrument_id}"
+        self.exch_inst_ = exch_inst
+        self.interval_sec_ = interval_sec
+        self.history_depth_sec_ = history_depth_sec
+
+        self.history_ = []
+        self.callbacks_ = []
+        self.timer_ = None
+
+    def add_callback(self, cb: MdSummaryCallbackT) -> None:
+        self.callbacks_.append(cb)
+
+    def __hash__(self):
+        return hash(
+            (
+                self.exch_acct_,
+                self.exch_inst_.instrument_id(),
+                self.interval_sec_,
+                self.history_depth_sec_,
+            )
+        )
+
+    def rqst_data(self) -> Dict[str, Any]:
+        return {
+            "exch_acct": self.exch_acct_,
+            "instrument_id": self.exch_inst_.instrument_id(),
+            "interval_sec": self.interval_sec_,
+            "history_depth_sec": self.history_depth_sec_,
+        }
+
+    def get_history(self) -> List[MdSummary]:
+        response: requests.Response = self.sender_.send_post(
+            endpoint="md_summary", post_body=self.rqst_data()
+        )
+        if response.status_code not in (200, 201):
+            Log.error(
+                f"{self.fname()}: Received error: {response.status_code} - {response.text}"
+            )
+            return []
+        return MdSummary.from_REST_response(response=response)
+
+    def get_last(self) -> Optional[MdSummary]:
+        Log.info(f"{self.fname()}: for {self.exch_inst_.details_short()}")
+        rqst_data = self.rqst_data()
+        rqst_data["history_depth_sec"] = self.interval_sec_ * 2
+        response: requests.Response = self.sender_.send_post(
+            endpoint="md_summary", post_body=rqst_data
+        )
+        if response.status_code not in (200, 201):
+            Log.error(
+                f"{self.fname()}: Received error: {response.status_code} - {response.text}"
+            )
+            return None
+        res = MdSummary.from_REST_response(response=response)
+        Log.info(f"DEBUG *** {self.exch_inst_.base_asset_id_}: {res[-1].tstamp_}")
+        return None if len(res) == 0 else res[-1]
+
+    def is_empty(self) -> bool:
+        return len(self.history_) == 0
+
+    async def start(self) -> None:
+        if self.timer_:
+            Log.error(f"{self.fname()}: Timer is already started")
+            return
+        mdsum_hist = self.get_history()
+        self.history_ = [
+            mdsum.create_md_trades_aggregate(
+                exch_acct=self.exch_acct_,
+                exch_inst=self.exch_inst_,
+                interval_sec=self.interval_sec_,
+            )
+            for mdsum in mdsum_hist
+        ]
+        await self.run_callbacks()
+        self.set_timer()
+
+    def set_timer(self):
+        if self.timer_:
+            self.timer_.cancel()
+        start_in = self.next_load_time() - current_seconds()
+        self.timer_ = Timer(
+            start_in_sec=start_in,
+            func=self._load_new,
+        )
+        Log.info(f"{self.fname()} Timer for {self.exch_inst_.details_short()} is set to run in {start_in} sec")
+
+    def next_load_time(self) -> NanosT:
+        ALLOW_LAG_SEC = 1
+        curr_sec = int(current_seconds())
+        return (curr_sec - curr_sec % self.interval_sec_) + self.interval_sec_ + ALLOW_LAG_SEC
+
+    async def _load_new(self) -> None:
+
+        last: Optional[MdSummary] = self.get_last()
+        if not last:
+            Log.warning(f"{self.fname()}: did not get last update")
+        elif not self.is_empty() and last.ts_ns_ <= self.history_[-1].aggr_time_ns_:
+            Log.info(
+                f"{self.fname()}: Received {last}. Already Have: {self.history_[-1]}"
+            )
+        else:
+            self.history_.append(last.create_md_trades_aggregate(exch_acct=self.exch_acct_, exch_inst=self.exch_inst_, interval_sec=self.interval_sec_))
+            await self.run_callbacks()
+        self.set_timer()
+
+    async def run_callbacks(self) -> None:
+        [await cb(self.history_) for cb in self.callbacks_]
+
+    def stop(self) -> None:
+        if self.timer_:
+            self.timer_.cancel()
+            self.timer_ = None
+
+
+class CvttRestMktDataClient(NamedObject):
+    config_: Config
+    sender_: RESTSender
+    collectors_: Set[MdSummaryCollector]
+
+    def __init__(self, config: Config) -> None:
+        self.config_ = config
+        base_url = self.config_.get_value("cvtt_base_url", default="")
+        assert base_url
+        self.sender_ = RESTSender(base_url=base_url)
+        self.collectors_ = set()
+
+    async def add_subscription(
+        self,
+        exch_acct: ExchangeAccountNameT,
+        instrument_id: InstrumentIdT,
+        interval_sec: IntervalSecT,
+        history_depth_sec: IntervalSecT,
+        callback: MdSummaryCallbackT,
+    ) -> None:
+        mdsc = MdSummaryCollector(
+            sender=self.sender_,
+            exch_acct=exch_acct,
+            instrument_id=instrument_id,
+            interval_sec=interval_sec,
+            history_depth_sec=history_depth_sec,
+        )
+        mdsc.add_callback(callback)
+        self.collectors_.add(mdsc)
+        await mdsc.start()
+
+
+if __name__ == "__main__":
+    config = Config(json_src={"cvtt_base_url": "http://cvtt-tester-01.cvtt.vpn:23456"})
+    # config = Config(json_src={"cvtt_base_url": "http://dev-server-02.cvtt.vpn:23456"})
+
+    async def _calback(history: List[MdTradesAggregate]) -> None:
+        Log.info(
+            f"MdSummary Hist Length is {len(history)}. Last summary: {history[-1] if  len(history) > 0 else '[]'}"
+        )
+
+    async def __run() -> None:
+        Log.info("Starting...")
+        cvtt_client = CvttRestMktDataClient(config)
+        await cvtt_client.add_subscription(
+            exch_acct="COINBASE_AT",
+            instrument_id="PAIR-BTC-USD",
+            interval_sec=60,
+            history_depth_sec=24 * 3600,
+            callback=_calback,
+        )
+        while True:
+            await asyncio.sleep(5)
+
+    asyncio.run(__run())
+    pass

__SAV__/lib/live/rest.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Dict, Optional
+import time
+
+import requests
+
+from cvttpy_tools.base.base import NamedObject
+
+class RESTSender(NamedObject):
+    # Synchronous request sernder
+    session_: requests.Session
+    base_url_: str
+
+    def __init__(self, base_url: str) -> None:
+        self.base_url_ = base_url
+        self.session_ = requests.Session()
+
+    def is_ready(self) -> bool:
+        """Checks if the server is up and responding"""
+        url = f"{self.base_url_}/ping"
+        try:
+            response = self.session_.get(url)
+            response.raise_for_status()
+            return True
+        except requests.exceptions.RequestException:
+            return False
+
+    def send_post(
+        self, endpoint: str, post_body: Dict, headers: Optional[Dict[str, str]] = None
+    ) -> requests.Response:
+
+        if not headers:
+            headers = {"Content-Type": "application/json"}
+        url = f"{self.base_url_}/{endpoint}"
+        try:
+            return self.session_.request(
+                method="POST",
+                url=url,
+                json=post_body,
+                headers=headers,
+            )
+        except requests.exceptions.RequestException as excpt:
+            raise ConnectionError(
+                f"Failed to send status={excpt.response.status_code} {excpt.response.text}"  # type: ignore
+            ) from excpt
+
+    def send_get(
+        self, endpoint: str, headers: Optional[Dict[str, str]] = None
+    ) -> requests.Response:
+        if not headers:
+            headers = {}
+        url = f"{self.base_url_}/{endpoint}"
+        try:
+            return self.session_.request(method="GET", url=url, headers=headers)
+        except requests.exceptions.RequestException as excpt:
+            raise ConnectionError(
+                f"Failed to send status={excpt.response.status_code} {excpt.response.text}"  # type: ignore
+            ) from excpt
+

__SAV__/lib/live/ti_sender.py

@@ -0,0 +1,50 @@
+from enum import Enum
+
+import requests
+
+# import aiohttp
+from cvttpy_tools.base.base import NamedObject
+from cvttpy_tools.base.config import Config
+from cvttpy_tools.base.logger import Log
+# ---
+from cvttpy_trading.trading.trading_instructions import TradingInstructions
+# ---
+from pairs_trading.apps.pair_trader import PairTrader
+from pairs_trading.lib.live.rest import RESTSender
+
+
+class TradingInstructionsSender(NamedObject):
+    config_: Config
+    sender_: RESTSender
+    pairs_trader_: PairTrader
+
+    class TradingInstType(str, Enum):
+        TARGET_POSITION = "TARGET_POSITION"
+        DIRECT_ORDER = "DIRECT_ORDER"
+        MARKET_MAKING = "MARKET_MAKING"
+        NONE = "NONE"
+
+    def __init__(self, config: Config, pairs_trader: PairTrader) -> None:
+        self.config_ = config
+        base_url = self.config_.get_value("cvtt_base_url", default="")
+        assert base_url
+        self.sender_ = RESTSender(base_url=base_url)
+        self.pairs_trader_ = pairs_trader
+        
+        self.book_id_ = self.pairs_trader_.book_id_
+        assert self.book_id_, "book_id is required"
+        
+        self.strategy_id_ = config.get_value("strategy_id", "")
+        assert self.strategy_id_, "strategy_id is required"
+        
+
+    async def send_trading_instructions(self, ti: TradingInstructions) -> None:
+        Log.info(f"{self.fname()}: sending {ti=}")
+        response: requests.Response = self.sender_.send_post(
+            endpoint="trading_instructions", post_body=ti.to_dict()
+        )
+        if response.status_code not in (200, 201):
+            Log.error(
+                f"{self.fname()}: Received error: {response.status_code} - {response.text}"
+            )
+

__SAV__/lib/pt_strategy/live/live_strategy.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+# ---
+from cvttpy_tools.base.base import NamedObject
+from cvttpy_tools.base.app import App
+from cvttpy_tools.base.config import Config
+from cvttpy_tools.settings.cvtt_types import IntervalSecT
+from cvttpy_tools.base.timeutils import NanosT, SecPerHour, current_nanoseconds, NanoPerSec, format_nanos_utc
+from cvttpy_tools.base.logger import Log
+
+# ---
+from cvttpy_trading.trading.instrument import ExchangeInstrument
+from cvttpy_trading.trading.mkt_data.md_summary import MdTradesAggregate
+from cvttpy_trading.trading.trading_instructions import TradingInstructions
+from cvttpy_trading.trading.trading_instructions import TargetPositionSignal
+
+# ---
+from pairs_trading.lib.pt_strategy.model_data_policy import ModelDataPolicy
+from pairs_trading.lib.pt_strategy.pt_model import Prediction
+from pairs_trading.lib.pt_strategy.trading_pair import LiveTradingPair
+from pairs_trading.apps.pair_trader import PairTrader
+from pairs_trading.lib.pt_strategy.pt_market_data import LiveMarketData
+
+
+class PtLiveStrategy(NamedObject):
+    config_: Config
+    instruments_: List[ExchangeInstrument]
+
+    interval_sec_: IntervalSecT
+    history_depth_sec_: IntervalSecT
+    open_threshold_: float
+    close_threshold_: float
+
+    trading_pair_: LiveTradingPair
+    model_data_policy_: ModelDataPolicy
+    pairs_trader_: PairTrader
+
+    # for presentation: history of prediction values and trading signals
+    predictions_df_: pd.DataFrame
+    trading_signals_df_: pd.DataFrame
+    allowed_md_lag_sec_: int
+
+
+    def __init__(
+        self,
+        config: Config,
+        pairs_trader: PairTrader,
+    ):
+        self.config_ = config
+
+        self.pairs_trader_ = pairs_trader
+        self.trading_pair_ = LiveTradingPair(
+            config=config,
+            instruments=self.pairs_trader_.instruments_,
+        )
+        self.model_data_policy_ = ModelDataPolicy.create(
+            self.config_,
+            is_real_time=True,
+            pair=self.trading_pair_,
+        )
+        assert (
+            self.model_data_policy_ is not None
+        ), f"{self.fname()}: Unable to create ModelDataPolicy"
+
+        self.predictions_df_ = pd.DataFrame()
+        self.trading_signals_df_ = pd.DataFrame()
+
+        self.instruments_ = self.pairs_trader_.instruments_
+
+        App.instance().add_call(
+            stage=App.Stage.Config, func=self._on_config(), can_run_now=True
+        )
+
+    async def _on_config(self) -> None:
+        self.interval_sec_ = self.config_.get_value("interval_sec", 0)
+        assert self.interval_sec_ > 0, "interval_sec cannot be 0"
+        self.history_depth_sec_ = (
+            self.config_.get_value("history_depth_hours", 0) * SecPerHour
+        )
+        assert self.history_depth_sec_ > 0, "history_depth_hours cannot be 0"
+
+        self.allowed_md_lag_sec_ = self.config_.get_value("allowed_md_lag_sec", 3)
+
+        self.open_threshold_ = self.config_.get_value(
+            "model/disequilibrium/open_trshld", 0.0
+        )
+        self.close_threshold_ = self.config_.get_value(
+            "model/disequilibrium/close_trshld", 0.0
+        )
+
+        assert (
+            self.open_threshold_ > 0
+        ), "disequilibrium/open_trshld must be greater than 0"
+        assert (
+            self.close_threshold_ > 0
+        ), "disequilibrium/close_trshld must be greater than 0"
+
+        await self.pairs_trader_.subscribe_md()
+
+
+    def __repr__(self) -> str:
+        return f"{self.classname()}: trading_pair={self.trading_pair_}, mdp={self.model_data_policy_.__class__.__name__}, "
+
+    async def on_mkt_data_hist_snapshot(
+        self, hist_aggr: List[MdTradesAggregate]
+    ) -> None:
+        if not self._is_md_actual(hist_aggr=hist_aggr):
+            return
+
+        market_data_df: pd.DataFrame = self._create_md_df(hist_aggr=hist_aggr)
+        if len(market_data_df) == 0:
+            Log.warning(f"{self.fname()} Unable to create market data df")
+            return
+
+        self.trading_pair_.market_data_ = market_data_df
+
+        Log.info(f"{self.fname()}: Running prediction for pair: {self.trading_pair_}")
+        prediction = self.trading_pair_.run(
+            market_data_df, self.model_data_policy_.advance()
+        )
+        self.predictions_df_ = pd.concat(
+            [self.predictions_df_, prediction.to_df()], ignore_index=True
+        )
+
+        trading_instructions: List[TradingInstructions] = (
+            self._create_trading_instructions(
+                prediction=prediction, last_row=market_data_df.iloc[-1]
+            )
+        )
+        if trading_instructions is not None:
+            await self._send_trading_instructions(trading_instructions)
+
+    def _is_md_actual(self, hist_aggr: List[MdTradesAggregate]) -> bool:
+        if len(hist_aggr) == 0:
+            Log.warning(f"{self.fname()} list of aggregates IS EMPTY")
+            return False
+
+        curr_ns = current_nanoseconds()
+        
+        # MAYBE check market data length
+        
+        # at 18:05:01 we should see data for 18:04:00
+        lag_sec = (curr_ns - hist_aggr[-1].aggr_time_ns_) / NanoPerSec - self.interval_sec()
+        if lag_sec > self.allowed_md_lag_sec_:
+            Log.warning(
+                f"{self.fname()} {hist_aggr[-1].exch_inst_.details_short()}"
+                f" Lagging {int(lag_sec)} > {self.allowed_md_lag_sec_} seconds:"
+                f"\n{len(hist_aggr)} records"
+                f"\n{hist_aggr[-1].exch_inst_.base_asset_id_}: {hist_aggr[-1].tstamp()}"
+                f"\n{hist_aggr[-2].exch_inst_.base_asset_id_}: {hist_aggr[-2].tstamp()}"
+            )
+            return False
+        else:
+            Log.info(
+                f"{self.fname()} {hist_aggr[-1].exch_inst_.details_short()}"
+                f" Lag {int(lag_sec)} <= {self.allowed_md_lag_sec_} seconds"
+                f"\n{len(hist_aggr)} records"
+                f"\n{hist_aggr[-1].exch_inst_.base_asset_id_}: {hist_aggr[-1].tstamp()}"
+                f"\n{hist_aggr[-2].exch_inst_.base_asset_id_}: {hist_aggr[-2].tstamp()}"
+            )
+        return True
+
+    def _create_md_df(self, hist_aggr: List[MdTradesAggregate]) -> pd.DataFrame:
+        """
+                          tstamp              time_ns    symbol      open      high       low     close     volume  num_trades        vwap
+        0    2025-09-10 11:30:00  1757503800000000000  ADA-USDT    0.8750    0.8750    0.8743    0.8743  50710.500           0    0.874489
+        1    2025-09-10 11:30:00  1757503800000000000  SOL-USDT  219.9700  219.9800  219.6600  219.7000   2648.582           0  219.787847
+        2    2025-09-10 11:31:00  1757503860000000000  SOL-USDT  219.7000  219.7300  219.6200  219.6200   1134.886           0  219.663460
+        3    2025-09-10 11:31:00  1757503860000000000  ADA-USDT    0.8743    0.8745    0.8741    0.8741  10696.400           0    0.874234
+        4    2025-09-10 11:32:00  1757503920000000000  ADA-USDT    0.8742    0.8742    0.8739    0.8740  18546.900           0    0.874037
+        """
+
+        rows: List[Dict[str, Any]] = []
+
+        for aggr in hist_aggr:
+            exch_inst = aggr.exch_inst_
+
+            rows.append(
+                {
+                    # convert nanoseconds → tz-aware pandas timestamp
+                    "tstamp": pd.to_datetime(aggr.aggr_time_ns_, unit="ns", utc=True),
+                    "time_ns": aggr.aggr_time_ns_,
+                    "symbol": exch_inst.instrument_id().split("-", 1)[1],
+                    "exchange_id": exch_inst.exchange_id_,
+                    "instrument_id": exch_inst.instrument_id(),
+                    "open": exch_inst.get_price(aggr.open_),
+                    "high": exch_inst.get_price(aggr.high_),
+                    "low": exch_inst.get_price(aggr.low_),
+                    "close": exch_inst.get_price(aggr.close_),
+                    "volume": exch_inst.get_quantity(aggr.volume_),
+                    "num_trades": aggr.num_trades_,
+                    "vwap": exch_inst.get_price(aggr.vwap_),
+                }
+            )
+
+        source_md_df = pd.DataFrame(
+            rows,
+            columns=[
+                "tstamp",
+                "time_ns",
+                "symbol",
+                "exchange_id",
+                "instrument_id",
+                "open",
+                "high",
+                "low",
+                "close",
+                "volume",
+                "num_trades",
+                "vwap",
+            ],
+        )
+
+        # automatic sorting
+        source_md_df.sort_values(
+            by=["time_ns", "symbol"],
+            ascending=True,
+            inplace=True,
+            kind="mergesort",  # stable sort
+        )
+
+        source_md_df.reset_index(drop=True, inplace=True)
+
+        pt_mkt_data = LiveMarketData(config=self.config_, instruments=self.instruments_)
+        pt_mkt_data.origin_mkt_data_df_ = source_md_df
+        pt_mkt_data.set_market_data()
+
+        return pt_mkt_data.market_data_df_
+
+    def interval_sec(self) -> IntervalSecT:
+        return self.interval_sec_
+
+    def history_depth_sec(self) -> IntervalSecT:
+        return self.history_depth_sec_
+
+    async def _send_trading_instructions(
+        self, trading_instructions: List[TradingInstructions]
+    ) -> None:
+        for ti in trading_instructions:
+            Log.info(f"{self.fname()} Sending trading instructions {ti}")
+            await self.pairs_trader_.ti_sender_.send_trading_instructions(ti)
+
+    def _create_trading_instructions(
+        self, prediction: Prediction, last_row: pd.Series
+    ) -> List[TradingInstructions]:
+        trd_instructions: List[TradingInstructions] = []
+        pair = self.trading_pair_
+
+        scaled_disequilibrium = prediction.scaled_disequilibrium_
+        abs_scaled_disequilibrium = abs(scaled_disequilibrium)
+
+        if abs_scaled_disequilibrium >= self.open_threshold_:
+            trd_instructions = self._create_open_trade_instructions(
+                pair, row=last_row, prediction=prediction
+            )
+
+        elif abs_scaled_disequilibrium <= self.close_threshold_ or pair.to_stop_close_conditions(predicted_row=last_row):
+            trd_instructions = self._create_close_trade_instructions(
+                pair, row=last_row  # , prediction=prediction
+            )
+
+
+        return trd_instructions
+    
+    def _strength(self, scaled_disequilibrium: float) -> float:
+        # TODO PtLiveStrategy._strength()
+        return 1.0
+
+    def _create_open_trade_instructions(
+        self, pair: LiveTradingPair, row: pd.Series, prediction: Prediction
+    ) -> List[TradingInstructions]:
+        diseqlbrm = prediction.disequilibrium_
+        scaled_disequilibrium = prediction.scaled_disequilibrium_
+        if diseqlbrm > 0:
+            side_a = -1
+            side_b = 1
+        else:
+            side_a = 1
+            side_b = -1
+
+        ti_a: Optional[TradingInstructions] = TradingInstructions(
+            book=self.pairs_trader_.book_id_,
+            strategy_id=self.__class__.__name__,
+            ti_type=TradingInstructions.Type.TARGET_POSITION,
+            issued_ts_ns=current_nanoseconds(),
+            data=TargetPositionSignal(
+                strength=side_a * self._strength(scaled_disequilibrium),
+                exchange_id=pair.get_instrument_a().exchange_id_,
+                base_asset=pair.get_instrument_a().base_asset_id_,
+                quote_asset=pair.get_instrument_a().quote_asset_id_,
+                user_data={}
+            ),
+        )
+        if not ti_a:
+            return []
+        ti_b: Optional[TradingInstructions] = TradingInstructions(
+            book=self.pairs_trader_.book_id_,
+            strategy_id=self.__class__.__name__,
+            ti_type=TradingInstructions.Type.TARGET_POSITION,
+            issued_ts_ns=current_nanoseconds(),
+            data=TargetPositionSignal(
+                strength=side_b * self._strength(scaled_disequilibrium),
+                exchange_id=pair.get_instrument_b().exchange_id_,
+                base_asset=pair.get_instrument_b().base_asset_id_,
+                quote_asset=pair.get_instrument_b().quote_asset_id_,
+                user_data={}
+            ),
+        )
+        if not ti_b:
+            return []
+        return [ti_a, ti_b]
+
+
+    def _create_close_trade_instructions(
+        self, pair: LiveTradingPair, row: pd.Series
+    ) -> List[TradingInstructions]:
+        ti_a: Optional[TradingInstructions] = TradingInstructions(
+            book=self.pairs_trader_.book_id_,
+            strategy_id=self.__class__.__name__,
+            ti_type=TradingInstructions.Type.TARGET_POSITION,
+            issued_ts_ns=current_nanoseconds(),
+            data=TargetPositionSignal(
+                strength=0,
+                exchange_id=pair.get_instrument_a().exchange_id_,
+                base_asset=pair.get_instrument_a().base_asset_id_,
+                quote_asset=pair.get_instrument_a().quote_asset_id_,
+                user_data={}
+            ),
+        )
+        if not ti_a:
+            return []
+        ti_b: Optional[TradingInstructions] = TradingInstructions(
+            book=self.pairs_trader_.book_id_,
+            strategy_id=self.__class__.__name__,
+            ti_type=TradingInstructions.Type.TARGET_POSITION,
+            issued_ts_ns=current_nanoseconds(),
+            data=TargetPositionSignal(
+                strength=0,
+                exchange_id=pair.get_instrument_b().exchange_id_,
+                base_asset=pair.get_instrument_b().base_asset_id_,
+                quote_asset=pair.get_instrument_b().quote_asset_id_,
+                user_data={}
+            ),
+        )
+        if not ti_b:
+            return []
+        return [ti_a, ti_b]

__SAV__/lib/pt_strategy/model_data_policy.py

@@ -8,31 +8,25 @@ from typing import Any, Dict, Optional, cast
 import numpy as np
 import pandas as pd
 
+from cvttpy_tools.base.config import Config
 
 @dataclass
 class DataWindowParams:
-    training_size: int
+    training_size_: int
-    training_start_index: int
+    training_start_index_: int
 
 
 class ModelDataPolicy(ABC):
-    config_: Dict[str, Any]
+    config_: Config
     current_data_params_: DataWindowParams
     count_: int
     is_real_time_: bool
 
-    def __init__(self, config: Dict[str, Any], *args: Any, **kwargs: Any):
+    def __init__(self, config: Config, *args: Any, **kwargs: Any):
         self.config_ = config
-        training_size = config.get("training_size", 120)
-        training_start_index = 0
-        if kwargs.get("is_real_time", False):
-            training_size = 120
-            training_start_index = 0
-        else:
-            training_size = config.get("training_size", 120)
         self.current_data_params_ = DataWindowParams(
-            training_size=config.get("training_size", 120),
+            training_size_=config.get_value("model/training_size", 120),
-            training_start_index=0,
+            training_start_index_=0,
         )
         self.count_ = 0
         self.is_real_time_ = kwargs.get("is_real_time", False)
@@ -40,14 +34,15 @@ class ModelDataPolicy(ABC):
     @abstractmethod
     def advance(self, mkt_data_df: Optional[pd.DataFrame] = None) -> DataWindowParams:
         self.count_ += 1
-        print(self.count_, end="\r")
+        if not self.is_real_time_:
+            print(self.count_, end="\r")
         return self.current_data_params_
 
     @staticmethod
-    def create(config: Dict[str, Any], *args: Any, **kwargs: Any) -> ModelDataPolicy:
+    def create(config: Config, *args: Any, **kwargs: Any) -> ModelDataPolicy:
         import importlib
 
-        model_data_policy_class_name = config.get("model_data_policy_class", None)
+        model_data_policy_class_name = config.get_value("model/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)
@@ -58,16 +53,18 @@ class ModelDataPolicy(ABC):
 
 
 class RollingWindowDataPolicy(ModelDataPolicy):
-    def __init__(self, config: Dict[str, Any], *args: Any, **kwargs: Any):
+    def __init__(self, config: Config, *args: Any, **kwargs: Any):
         super().__init__(config, *args, **kwargs)
         self.count_ = 1
 
     def advance(self, mkt_data_df: Optional[pd.DataFrame] = None) -> DataWindowParams:
         super().advance(mkt_data_df)
         if self.is_real_time_:
-            self.current_data_params_.training_start_index = -self.current_data_params_.training_size
+            self.current_data_params_.training_start_index_ = 0
+            if mkt_data_df and len(mkt_data_df) > self.curren_data_params_.training_size_:
+                self.current_data_params_.training_start_index_ = -self.curren_data_params_.training_size_ 
         else:
-            self.current_data_params_.training_start_index += 1
+            self.current_data_params_.training_start_index_ += 1
         return self.current_data_params_
 
 
@@ -80,18 +77,17 @@ class OptimizedWndDataPolicy(ModelDataPolicy, ABC):
     prices_a_: np.ndarray
     prices_b_: np.ndarray
 
-    def __init__(self, config: Dict[str, Any], *args: Any, **kwargs: Any):
+    def __init__(self, config: Config, *args: Any, **kwargs: Any):
         super().__init__(config, *args, **kwargs)
         assert (
             kwargs.get("pair") is not None
         ), "pair must be provided"
-        assert (
+        assert (config.key_exists("model/max_training_size") and config.key_exists("model/min_training_size")
-            "min_training_size" in config and "max_training_size" in config
+            ), "min_training_size and max_training_size must be provided"
-        ), "min_training_size and max_training_size must be provided"
+        self.min_training_size_ = cast(int, config.get_value("model/min_training_size"))
-        self.min_training_size_ = cast(int, config.get("min_training_size"))
+        self.max_training_size_ = cast(int, config.get_value("model/max_training_size"))
-        self.max_training_size_ = cast(int, config.get("max_training_size"))
 
-        from pt_strategy.trading_pair import TradingPair
+        from pairs_trading.lib.pt_strategy.trading_pair import TradingPair
         self.pair_ = cast(TradingPair, kwargs.get("pair"))        
         
         if "mkt_data" in kwargs:
@@ -110,12 +106,12 @@ class OptimizedWndDataPolicy(ModelDataPolicy, ABC):
         if self.is_real_time_:
             self.end_index_ = len(self.mkt_data_df_) - 1
         else:
-            self.end_index_ = self.current_data_params_.training_start_index + self.max_training_size_
+            self.end_index_ = self.current_data_params_.training_start_index_ + self.max_training_size_
             if self.end_index_ > len(self.mkt_data_df_) - 1:
                 self.end_index_ = len(self.mkt_data_df_) - 1
-                self.current_data_params_.training_start_index = self.end_index_ - self.max_training_size_
+                self.current_data_params_.training_start_index_ = self.end_index_ - self.max_training_size_
-                if self.current_data_params_.training_start_index < 0:
+                if self.current_data_params_.training_start_index_ < 0:
-                    self.current_data_params_.training_start_index = 0
+                    self.current_data_params_.training_start_index_ = 0
 
         col_a, col_b = self.pair_.colnames()
         self.prices_a_ = np.array(self.mkt_data_df_[col_a])
@@ -133,7 +129,7 @@ class EGOptimizedWndDataPolicy(OptimizedWndDataPolicy):
     # Engle-Granger cointegration test
     *** VERY SLOW ***
     '''
-    def __init__(self, config: Dict[str, Any], *args: Any, **kwargs: Any):
+    def __init__(self, config: Config, *args: Any, **kwargs: Any):
         super().__init__(config, *args, **kwargs)
 
     def optimize_window_size(self) -> DataWindowParams:
@@ -152,8 +148,8 @@ class EGOptimizedWndDataPolicy(OptimizedWndDataPolicy):
             eg_pvalue = float(coint(series_a, series_b)[1])
             if eg_pvalue < last_pvalue:
                 last_pvalue = eg_pvalue
-                result.training_size = trn_size
+                result.training_size_ = trn_size
-                result.training_start_index = start_index
+                result.training_start_index_ = start_index
 
         # print(
         #     f"*** DEBUG *** end_index={self.end_index_}, best_trn_size={self.current_data_params_.training_size}, {last_pvalue=}"
@@ -162,7 +158,7 @@ class EGOptimizedWndDataPolicy(OptimizedWndDataPolicy):
 
 class ADFOptimizedWndDataPolicy(OptimizedWndDataPolicy):
     # Augmented Dickey-Fuller test
-    def __init__(self, config: Dict[str, Any], *args: Any, **kwargs: Any):
+    def __init__(self, config: Config, *args: Any, **kwargs: Any):
         super().__init__(config, *args, **kwargs)
 
     def optimize_window_size(self) -> DataWindowParams:
@@ -196,8 +192,8 @@ class ADFOptimizedWndDataPolicy(OptimizedWndDataPolicy):
 
             if adf_pvalue < last_pvalue:
                 last_pvalue = adf_pvalue
-                result.training_size = trn_size
+                result.training_size_ = trn_size
-                result.training_start_index = start_index
+                result.training_start_index_ = start_index
 
         # print(
         #     f"*** DEBUG *** end_index={self.end_index_},"
@@ -208,7 +204,7 @@ class ADFOptimizedWndDataPolicy(OptimizedWndDataPolicy):
     
 class JohansenOptdWndDataPolicy(OptimizedWndDataPolicy):
     # Johansen test
-    def __init__(self, config: Dict[str, Any], *args: Any, **kwargs: Any):
+    def __init__(self, config: Config, *args: Any, **kwargs: Any):
         super().__init__(config, *args, **kwargs)
 
     def optimize_window_size(self) -> DataWindowParams:
@@ -246,8 +242,8 @@ class JohansenOptdWndDataPolicy(OptimizedWndDataPolicy):
                 continue
 
         if best_trn_size > 0:
-            result.training_size = best_trn_size
+            result.training_size_ = best_trn_size
-            result.training_start_index = best_start_index
+            result.training_start_index_ = best_start_index
         else:
             print("*** WARNING: No valid cointegration window found.")
 

__SAV__/lib/pt_strategy/models.py

@@ -6,8 +6,8 @@ import statsmodels.api as sm
 
 
 
-from pt_strategy.pt_model import PairsTradingModel, Prediction
+from pairs_trading.lib.pt_strategy.pt_model import PairsTradingModel, Prediction
-from pt_strategy.trading_pair import TradingPair
+from pairs_trading.lib.pt_strategy.trading_pair import TradingPair
 
 
 class OLSModel(PairsTradingModel):

__SAV__/lib/pt_strategy/pt_market_data.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+# ---
+from cvttpy_tools.base.base import NamedObject
+from cvttpy_tools.base.config import Config
+from cvttpy_tools.settings.cvtt_types import JsonDictT
+
+# ---
+from cvttpy_trading.trading.mkt_data.md_summary import MdTradesAggregate
+from cvttpy_trading.trading.instrument import ExchangeInstrument
+# ---
+from pairs_trading.lib.tools.data_loader import load_market_data
+
+
+class PtMarketData(NamedObject, ABC):
+    config_: Config
+    origin_mkt_data_df_: pd.DataFrame
+    market_data_df_: pd.DataFrame
+    stat_model_price_: str
+    instruments_: List[ExchangeInstrument]
+    symbol_a_: str
+    symbol_b_: str
+
+    def __init__(self, config: Config, instruments: List[ExchangeInstrument]):
+        self.config_ = config
+        self.origin_mkt_data_df_ = pd.DataFrame()
+        self.market_data_df_ = pd.DataFrame()
+        self.stat_model_price_ = self.config_.get_value("model/stat_model_price")
+
+        self.instruments_ = instruments
+        assert len(self.instruments_) > 0, "No instruments found in config"
+        self.symbol_a_ = self.instruments_[0].instrument_id().split("-", 1)[1]
+        self.symbol_b_ = self.instruments_[1].instrument_id().split("-", 1)[1]
+
+    @abstractmethod
+    def md_columns(self) -> List[str]: ...
+
+    @abstractmethod
+    def rename_columns(self, symbol_df: pd.DataFrame) -> pd.DataFrame: ...
+    
+    @abstractmethod
+    def tranform_df_target_colnames(self) -> List[str]: ...
+        
+    def set_market_data(self) -> None:
+        self.market_data_df_ = pd.DataFrame(
+            self._transform_dataframe(self.origin_mkt_data_df_)[
+                ["tstamp"] + self.tranform_df_target_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")
+
+    def colnames(self) -> List[str]:
+        return [
+            f"{self.stat_model_price_}_{self.symbol_a_}",
+            f"{self.stat_model_price_}_{self.symbol_b_}",
+        ]
+
+    def _transform_dataframe(self, df: pd.DataFrame) -> pd.DataFrame:
+        df_selected: pd.DataFrame = pd.DataFrame(df[self.md_columns()])
+        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"
+            temp_df: pd.DataFrame = self.rename_columns(df_symbol)
+            # 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()
+    
+class ResearchMarketData(PtMarketData):
+    current_index_: int
+    is_execution_price_: bool
+
+    def __init__(self, config: Config, instruments: List[ExchangeInstrument]):
+        super().__init__(config, instruments)
+        self.current_index_ = 0
+        self.is_execution_price_ = self.config_.key_exists("execution_price")
+        if self.is_execution_price_:
+            self.execution_price_column_ = self.config_.get_value("execution_price")["column"]
+            self.execution_price_shift_ = self.config_.get_value("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_value("datafiles", [])
+        assert len(datafiles) > 0, "No datafiles found in config"
+
+        extra_minutes: int = self.execution_price_shift_
+
+        for datafile in datafiles:
+            md_df = load_market_data(
+                datafile=datafile,
+                instruments=self.instruments_,
+                db_table_name=self.config_.get_value("market_data_loading")[
+                    self.instruments_[0].user_data_.get("instrument_type", "?instrument_type?")
+                ]["db_table_name"],
+                trading_hours=self.config_.get_value("trading_hours"),
+                extra_minutes=extra_minutes,
+            )
+            self.origin_mkt_data_df_ = pd.concat([self.origin_mkt_data_df_, md_df])
+
+        self.origin_mkt_data_df_ = self.origin_mkt_data_df_.sort_values(by="tstamp")
+        self.origin_mkt_data_df_ = self.origin_mkt_data_df_.dropna().reset_index(
+            drop=True
+        )
+        self.set_market_data()
+        self._set_execution_price_data()
+
+    def _set_execution_price_data(self) -> None:
+        if not self.is_execution_price_:
+            return
+        if not self.config_.key_exists("execution_price"):
+            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_.get_value("execution_price")["column"]
+        execution_price_shift = self.config_.get_value("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 md_columns(self) -> List[str]: 
+        # @abstractmethod
+        if self.is_execution_price_:
+            return ["tstamp", "symbol", self.stat_model_price_, self.execution_price_column_]
+        else:
+            return ["tstamp", "symbol", self.stat_model_price_]
+
+    def rename_columns(self, selected_symbol_df: pd.DataFrame) -> pd.DataFrame:  
+        # @abstractmethod
+        symbol = selected_symbol_df.iloc[0]["symbol"]
+        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": selected_symbol_df["tstamp"],
+                    new_price_column: selected_symbol_df[self.stat_model_price_],
+                    new_execution_price_column: selected_symbol_df[self.execution_price_column_],
+                }
+            )
+        else:
+            temp_df = pd.DataFrame(
+                {
+                    "tstamp": selected_symbol_df["tstamp"],
+                    new_price_column: selected_symbol_df[self.stat_model_price_],
+                }
+            )
+        return temp_df
+
+    def tranform_df_target_colnames(self):
+        # @abstractmethod
+        return self.colnames() + self.orig_exec_prices_colnames()
+    
+    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_}",
+        ] if self.is_execution_price_ else []
+
+class LiveMarketData(PtMarketData):
+
+    def __init__(self, config: Config, instruments: List[ExchangeInstrument]):
+        super().__init__(config, instruments)
+
+    def md_columns(self) -> List[str]: 
+        # @abstractmethod
+        return ["tstamp", "symbol", self.stat_model_price_]
+
+    def rename_columns(self, selected_symbol_df: pd.DataFrame) -> pd.DataFrame:  
+        # @abstractmethod
+        symbol = selected_symbol_df.iloc[0]["symbol"]
+        new_price_column = f"{self.stat_model_price_}_{symbol}"
+        temp_df = pd.DataFrame(
+            {
+                "tstamp": selected_symbol_df["tstamp"],
+                new_price_column: selected_symbol_df[self.stat_model_price_],
+            }
+        )
+        return temp_df
+
+    def tranform_df_target_colnames(self):
+        # @abstractmethod
+        return self.colnames()

__SAV__/lib/pt_strategy/pt_model.py

@@ -3,8 +3,11 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import Any, Dict, cast
 
-from pt_strategy.prediction import Prediction
+# ---
-
+from cvttpy_tools.base.config import Config
+# ---
+from pairs_trading.lib.pt_strategy.prediction import Prediction
+from pairs_trading.lib.pt_strategy.trading_pair import TradingPair
     
 class PairsTradingModel(ABC):
 
@@ -13,10 +16,10 @@ class PairsTradingModel(ABC):
         ...
     
     @staticmethod
-    def create(config: Dict[str, Any]) -> PairsTradingModel:
+    def create(config: Config) -> PairsTradingModel:
         import importlib
         
-        model_class_name = config.get("model_class", None)
+        model_class_name = config.get_value("model/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)

__SAV__/lib/pt_strategy/research_strategy.py

@@ -1,54 +1,56 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 import pandas as pd
-from pt_strategy.model_data_policy import ModelDataPolicy
+# ---
-from pt_strategy.pt_market_data import ResearchMarketData
+from cvttpy_tools.base.config import Config
-from pt_strategy.pt_model import Prediction
+# ---
-from pt_strategy.trading_pair import PairState, TradingPair
+from cvttpy_trading.trading.instrument import ExchangeInstrument
-
+# ---
+from pairs_trading.lib.pt_strategy.model_data_policy import ModelDataPolicy
+from pairs_trading.lib.pt_strategy.pt_market_data import ResearchMarketData
+from pairs_trading.lib.pt_strategy.pt_model import Prediction
+from pairs_trading.lib.pt_strategy.trading_pair import PairState, TradingPair, ResearchTradingPair
 
 class PtResearchStrategy:
-    config_: Dict[str, Any]
+    config_: Config
-    trading_pair_: TradingPair
+    trading_pair_: ResearchTradingPair
     model_data_policy_: ModelDataPolicy
     pt_mkt_data_: ResearchMarketData 
 
     trades_: List[pd.DataFrame]
-    predictions_: pd.DataFrame
+    predictions_df_: pd.DataFrame
 
     def __init__(
         self,
-        config: Dict[str, Any],
+        config: Config,
-        datafiles: List[str],
+        instruments: List[ExchangeInstrument]
-        instruments: List[Dict[str, str]],
     ):
-        from pt_strategy.model_data_policy import ModelDataPolicy
+        from pairs_trading.lib.pt_strategy.model_data_policy import ModelDataPolicy
-        from pt_strategy.trading_pair import TradingPair
+        from pairs_trading.lib.pt_strategy.trading_pair import TradingPair
 
         self.config_ = config
         self.trades_ = []
-        self.trading_pair_ = TradingPair(config=config, instruments=instruments)
+        self.trading_pair_ = ResearchTradingPair(config=config, instruments=instruments)
-        self.predictions_ = pd.DataFrame()
+        self.predictions_df_ = pd.DataFrame()
 
         import copy
 
         # modified config must be passed to PtMarketData
         config_copy = copy.deepcopy(config)
-        config_copy["instruments"] = instruments
+        config_copy.set_value("instruments", instruments)
-        config_copy["datafiles"] = datafiles
+        self.pt_mkt_data_ = ResearchMarketData(config=config_copy, instruments=instruments)
-        self.pt_mkt_data_ = ResearchMarketData(config=config_copy)
         self.pt_mkt_data_.load()
         self.model_data_policy_ = ModelDataPolicy.create(
-            config, mkt_data=self.pt_mkt_data_.market_data_df_, pair=self.trading_pair_
+            config_copy, mkt_data=self.pt_mkt_data_.market_data_df_, pair=self.trading_pair_
         )
 
     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)
+        training_minutes = self.config_.get_value("training_minutes", 120)
         market_data_series: pd.Series
         market_data_df = pd.DataFrame()
 
@@ -72,8 +74,8 @@ class PtResearchStrategy:
             prediction = self.trading_pair_.run(
                 market_data_df, self.model_data_policy_.advance(mkt_data_df=market_data_df)
             )
-            self.predictions_ = pd.concat(
+            self.predictions_df_ = pd.concat(
-                [self.predictions_, prediction.to_df()], ignore_index=True
+                [self.predictions_df_, prediction.to_df()], ignore_index=True
             )
             assert prediction is not None
 
@@ -93,8 +95,8 @@ class PtResearchStrategy:
         pair = self.trading_pair_
         trades = None
 
-        open_threshold = self.config_["dis-equilibrium_open_trshld"]
+        open_threshold = self.config_.get_value("model/disequilibrium/open_trshld")
-        close_threshold = self.config_["dis-equilibrium_close_trshld"]
+        close_threshold = self.config_.get_value("model/disequilibrium/close_trshld")
         scaled_disequilibrium = prediction.scaled_disequilibrium_
         abs_scaled_disequilibrium = abs(scaled_disequilibrium)
 
@@ -143,7 +145,7 @@ class PtResearchStrategy:
         if pair.user_data_["state"] == PairState.OPEN:
             print(f"{pair}:  *** Position is NOT CLOSED. ***")
             # outstanding positions
-            if self.config_["close_outstanding_positions"]:
+            if self.config_.get_value("close_outstanding_positions", False):
                 close_position_row = pd.Series(pair.market_data_.iloc[-2])
                 # close_position_row["disequilibrium"] = 0.0
                 # close_position_row["scaled_disequilibrium"] = 0.0
@@ -159,14 +161,14 @@ class PtResearchStrategy:
                     pair.on_close_trades(trades)
             else:
                 pair.add_outstanding_position(
-                    symbol=pair.symbol_a_,
+                    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_,
+                    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"],
@@ -190,7 +192,7 @@ class PtResearchStrategy:
         return pd.DataFrame(columns=columns).astype(types)
 
     def _create_open_trades(
-        self, pair: TradingPair, row: pd.Series, prediction: Prediction
+        self, pair: ResearchTradingPair, row: pd.Series, prediction: Prediction
     ) -> Optional[pd.DataFrame]:
         colname_a, colname_b = pair.exec_prices_colnames()
 
@@ -224,7 +226,7 @@ class PtResearchStrategy:
         # create opening trades
         df.loc[len(df)] = {
             "time": tstamp,
-            "symbol": pair.symbol_a_,
+            "symbol": pair.symbol_a(),
             "side": side_a,
             "action": "OPEN",
             "price": px_a,
@@ -235,7 +237,7 @@ class PtResearchStrategy:
         }
         df.loc[len(df)] = {
             "time": tstamp,
-            "symbol": pair.symbol_b_,
+            "symbol": pair.symbol_b(),
             "side": side_b,
             "action": "OPEN",
             "price": px_b,
@@ -247,7 +249,7 @@ class PtResearchStrategy:
         return df
 
     def _create_close_trades(
-        self, pair: TradingPair, row: pd.Series, prediction: Optional[Prediction] = None
+        self, pair: ResearchTradingPair, row: pd.Series, prediction: Optional[Prediction] = None
     ) -> Optional[pd.DataFrame]:
         colname_a, colname_b = pair.exec_prices_colnames()
 
@@ -269,7 +271,7 @@ class PtResearchStrategy:
         # create opening trades
         df.loc[len(df)] = {
             "time": tstamp,
-            "symbol": pair.symbol_a_,
+            "symbol": pair.symbol_a(),
             "side": pair.user_data_["close_side_a"],
             "action": "CLOSE",
             "price": px_a,
@@ -280,7 +282,7 @@ class PtResearchStrategy:
         }
         df.loc[len(df)] = {
             "time": tstamp,
-            "symbol": pair.symbol_b_,
+            "symbol": pair.symbol_b(),
             "side": pair.user_data_["close_side_b"],
             "action": "CLOSE",
             "price": px_b,

__SAV__/lib/pt_strategy/results.py

@@ -4,8 +4,12 @@ from datetime import date, datetime
 from typing import Any, Dict, List, Optional, Tuple
 
 import pandas as pd
-from pt_strategy.trading_pair import TradingPair
+# ---
-
+from cvttpy_tools.base.config import Config
+# ---
+from cvttpy_trading.trading.instrument import ExchangeInstrument
+# ---
+from pairs_trading.lib.pt_strategy.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
@@ -18,12 +22,10 @@ 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())
@@ -118,9 +120,9 @@ def create_result_database(db_path: str) -> None:
 def store_config_in_database(
     db_path: str,
     config_file_path: str,
-    config: Dict,
+    config: Config,
     datafiles: List[Tuple[str, str]],
-    instruments: List[Dict[str, str]],
+    instruments: List[ExchangeInstrument],
 ) -> None:
     """
     Store configuration information in the database for reference.
@@ -135,13 +137,13 @@ def store_config_in_database(
         cursor = conn.cursor()
 
         # Convert config to JSON string
-        config_json = json.dumps(config, indent=2, default=str)
+        config_json = json.dumps(config.data(), 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']}"
+                inst.details_short()
                 for inst in instruments
             ]
         )
@@ -204,9 +206,9 @@ class PairResearchResult:
     trades_: Dict[DayT, pd.DataFrame]
     outstanding_positions_: Dict[DayT, List[OutstandingPositionT]]
     symbol_roundtrip_trades_: Dict[str, List[Dict[str, Any]]]
-    
+    config_: Config
 
-    def __init__(self, config: Dict[str, Any]) -> None:
+    def __init__(self, config: Config) -> None:
         self.config_ = config
         self.trades_ = {}
         self.outstanding_positions_ = {}
@@ -218,13 +220,6 @@ class PairResearchResult:
         self.trades_[day] = trades
         self.outstanding_positions_[day] = outstanding_positions
 
-    # def all_trades(self) -> List[TradeT]:
-    #     """Get all trades across all days as a flat list."""
-    #     all_trades_list: List[TradeT] = []
-    #     for day_trades in self.trades_.values():
-    #         all_trades_list.extend(day_trades.to_dict(orient="records"))
-    #     return all_trades_list
-    
     def outstanding_positions(self) -> List[OutstandingPositionT]:
         """Get all outstanding positions across all days as a flat list."""
         res: List[Dict[str, Any]] = []
@@ -292,7 +287,7 @@ class PairResearchResult:
                 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
+                funding_per_position = self.config_.get_value("funding_per_pair", 10000) / 2
                 
                 # Symbol A round-trip
                 day_roundtrips.append({

__SAV__/lib/pt_strategy/trading_pair.py

@@ -1,13 +1,21 @@
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 from datetime import datetime
 from enum import Enum
 from typing import Any, Dict, List
 
 import pandas as pd
 
-from pt_strategy.model_data_policy import DataWindowParams
+# ---
-from pt_strategy.prediction import Prediction
+from cvttpy_tools.base.base import NamedObject
+from cvttpy_tools.base.config import Config
+# ---
+from cvttpy_trading.trading.instrument import ExchangeInstrument
+# ---
+from pairs_trading.lib.pt_strategy.model_data_policy import DataWindowParams
+from pairs_trading.lib.pt_strategy.prediction import Prediction
+
 
 
 class PairState(Enum):
@@ -19,59 +27,76 @@ class PairState(Enum):
     CLOSE_STOP_PROFIT = 6
 
 
-def get_symbol(instrument: Dict[str, str]) -> str:
+class TradingPair(NamedObject, ABC):
-    if "symbol" in instrument:
+    config_: Config
-        return instrument["symbol"]
+    model_: Any # "PairsTradingModel"
-    elif "instrument_id" in instrument:
-        instrument_id = instrument["instrument_id"]
-        instrument_pfx = instrument_id[:instrument_id.find("-") + 1]
-        symbol = instrument_id[len(instrument_pfx):]
-        instrument["symbol"] = symbol
-        instrument["instrument_id_pfx"] = instrument_pfx
-        return symbol
-    else:
-        raise ValueError(f"Invalid instrument: {instrument}, missing symbol or instrument_id")
-
-class TradingPair:
-    config_: Dict[str, Any]
     market_data_: pd.DataFrame
-    instruments_: List[Dict[str, str]]
+
-    symbol_a_: str
-    symbol_b_: str
-    
-    stat_model_price_: str
-    model_: PairsTradingModel  # type: ignore[assignment]
-    
     user_data_: Dict[str, Any]
+    stat_model_price_: str
+
+    instruments_: List[ExchangeInstrument]
 
     def __init__(
         self,
-        config: Dict[str, Any],
+        config: Config,
-        instruments: List[Dict[str, str]],
+        instruments: List[ExchangeInstrument],
     ):
-        
+        from pairs_trading.lib.pt_strategy.pt_model import PairsTradingModel
-        from pt_strategy.pt_model import PairsTradingModel
+
-        
-        assert len(instruments) == 2, "Trading pair must have exactly 2 instruments"
-        
         self.config_ = config
-        self.instruments_ = instruments
-        self.symbol_a_ = get_symbol(instruments[0])
-        self.symbol_b_ = get_symbol(instruments[1])
         self.model_ = PairsTradingModel.create(config)
-        self.stat_model_price_ = config["stat_model_price"]
+        self.user_data_ = {}
-        self.user_data_ = {
+        self.instruments_ = instruments
-            "state": PairState.INITIAL,
+        self.instruments_[0].user_data_["symbol"] = instruments[0].instrument_id().split("-", 1)[1]
-        }
+        self.instruments_[1].user_data_["symbol"] = instruments[1].instrument_id().split("-", 1)[1]        
+        self.stat_model_price_ = config.get_value("model/stat_model_price")
+        
+    def run(self, market_data: pd.DataFrame, data_params: DataWindowParams) -> 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)
+
+    def colnames(self) -> List[str]:
+        return [
+            f"{self.stat_model_price_}_{self.symbol_a()}",
+            f"{self.stat_model_price_}_{self.symbol_b()}",
+        ]
+    def symbol_a(self) -> str:
+        return self.get_instrument_a().user_data_["symbol"]
+    
+    def symbol_b(self) -> str:
+        return self.get_instrument_b().user_data_["symbol"]
+
+    def get_instrument_a(self) -> ExchangeInstrument:
+        return self.instruments_[0]
+
+    def get_instrument_b(self) -> ExchangeInstrument:
+        return self.instruments_[1]
 
     def __repr__(self) -> str:
         return (
             f"{self.__class__.__name__}:"
-            f" symbol_a={self.symbol_a_},"
+            f" symbol_a={self.symbol_a()},"
-            f" symbol_b={self.symbol_b_},"
+            f" symbol_b={self.symbol_b()},"
             f" model={self.model_.__class__.__name__}"
         )
     
+class ResearchTradingPair(TradingPair):
+
+    def __init__(
+        self,
+        config: Config,
+        instruments: List[ExchangeInstrument],
+    ):
+        assert len(instruments) == 2, "Trading pair must have exactly 2 instruments"
+        super().__init__(config=config, instruments=instruments)
+
+        self.user_data_ = {
+            "state": PairState.INITIAL,
+        }
+        
     def is_closed(self) -> bool:
         return self.user_data_["state"] in [
             PairState.CLOSE,
@@ -79,39 +104,34 @@ class TradingPair:
             PairState.CLOSE_STOP_LOSS,
             PairState.CLOSE_STOP_PROFIT,
         ]
+
     def is_open(self) -> bool:
-        return self.user_data_["state"] == PairState.OPEN
+        return not self.is_closed()
-    
-    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_a()}",
-            f"exec_price_{self.symbol_b_}",
+            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
+            not config.key_exists("stop_close_conditions")
-            or config["stop_close_conditions"] is None
+            or config.get_value("stop_close_conditions") is None
         ):
             return False
-        if "profit" in config["stop_close_conditions"]:
+        if "profit" in config.get_value("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"]:
+            if current_return >= config.get_value("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 "loss" in config.get_value("stop_close_conditions"):
-            if current_return <= config["stop_close_conditions"]["loss"]:
+            if current_return <= config.get_value("stop_close_conditions")["loss"]:
                 print(f"STOP LOSS: {current_return}")
                 self.user_data_["stop_close_state"] = PairState.CLOSE_STOP_LOSS
                 return True
@@ -136,8 +156,8 @@ class TradingPair:
                 )
                 return float(instrument_return) * 100.0
 
-            instrument_a_return = _single_instrument_return(self.symbol_a_)
+            instrument_a_return = _single_instrument_return(self.symbol_a())
-            instrument_b_return = _single_instrument_return(self.symbol_b_)
+            instrument_b_return = _single_instrument_return(self.symbol_b())
             return instrument_a_return + instrument_b_return
         return 0.0
 
@@ -158,42 +178,49 @@ class TradingPair:
         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 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_:
+        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
+        funding_per_position = self.config_.get_value("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({
+        self.user_data_["outstanding_positions"].append(
-            "symbol": symbol,
+            {
-            "open_side": open_side,
+                "symbol": symbol,
-            "open_px": open_px,
+                "open_side": open_side,
-            "shares": shares,
+                "open_px": open_px,
-            "open_tstamp": open_tstamp,
+                "shares": shares,
-            "last_px": last_px,
+                "open_tstamp": open_tstamp,
-            "last_tstamp": last_mkt_data_row["tstamp"],
+                "last_px": last_px,
-            "last_value": last_px * shares,
+                "last_tstamp": last_mkt_data_row["tstamp"],
-        })
+                "last_value": last_px * shares,
+            }
+        )
 
+class LiveTradingPair(TradingPair):
 
-    def run(self, market_data: pd.DataFrame, data_params: DataWindowParams) -> Prediction: # type: ignore[assignment]
+    def __init__(self, config: Config, instruments: List[ExchangeInstrument]):
-        self.market_data_ = market_data[data_params.training_start_index:data_params.training_start_index + data_params.training_size]
+        super().__init__(config, instruments)
-        return self.model_.predict(pair=self)
-
 
+    def to_stop_close_conditions(self, predicted_row: pd.Series) -> bool:
+        # TODO LiveTradingPair.to_stop_close_conditions()
+        return False
         
+

__SAV__/lib/tools/config.py

@@ -1,12 +1,12 @@
 import hjson
 from typing import Dict
 from datetime import datetime
+# ---
+from cvttpy_tools.base.config import Config
 
 
-def load_config(config_path: str) -> Dict:
+def load_config(config_path: str) -> Config:
-    with open(config_path, "r") as f:
+    return Config(json_src=f"file://{config_path}")
-        config = hjson.load(f)
-    return dict(config)
 
 
 def expand_filename(filename: str) -> str:

__SAV__/lib/tools/data_loader.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import sqlite3
-from typing import Dict, List, cast
+from typing import Any, Dict, List, Tuple, cast
 import pandas as pd
 
+from cvttpy_trading.trading.instrument import ExchangeInstrument
 
 def load_sqlite_to_dataframe(db_path:str, query:str) -> pd.DataFrame:
     df: pd.DataFrame = pd.DataFrame()
@@ -45,19 +46,17 @@ def convert_time_to_UTC(value: str, timezone: str, extra_minutes: int = 0) -> st
 
 def load_market_data(
     datafile: str,
-    instruments: List[Dict[str, str]],
+    instruments: List[ExchangeInstrument],
     db_table_name: str,
     trading_hours: Dict = {},
     extra_minutes: int = 0,
 ) -> pd.DataFrame:
 
-    insts = [
+
-        '"' + instrument["instrument_id_pfx"] + instrument["symbol"] + '"'
+    inst_ids = ['"' + exch_inst.instrument_id() + '"' for exch_inst in instruments]
-        for instrument in instruments
+    instrument_ids = list(set(inst_ids))
-    ]
-    instrument_ids = list(set(insts))
     exchange_ids = list(
-        set(['"' + instrument["exchange_id"] + '"' for instrument in instruments])
+        set(['"' + instrument.exchange_id() + '"' for instrument in instruments])
     )
 
     query = "select"

__SAV__/lib/tools/filetools.py

@@ -1,18 +1,22 @@
 import os
 import glob
 from typing import Dict, List, Tuple
+# ---
+from cvttpy_tools.base.config import Config
+# ---
+from cvttpy_trading.trading.instrument import ExchangeInstrument
 
 DayT = str
 DataFileNameT = str
 
 def resolve_datafiles(
-    config: Dict, date_pattern: str, instruments: List[Dict[str, str]]
+    config: Config, date_pattern: str, instruments: List[ExchangeInstrument]
 ) -> List[Tuple[DayT, DataFileNameT]]:
     resolved_files: List[Tuple[DayT, DataFileNameT]] = []
-    for inst in instruments:
+    for exch_inst in instruments:
         pattern = date_pattern
-        inst_type = inst["instrument_type"]
+        inst_type = exch_inst.user_data_.get("instrument_type", "?instrument_type?")
-        data_dir = config["market_data_loading"][inst_type]["data_directory"]
+        data_dir = config.get_value(f"market_data_loading/{inst_type}/data_directory")
         if "*" in pattern or "?" in pattern:
             # Handle wildcards
             if not os.path.isabs(pattern):

__SAV__/lib/tools/viz/viz_prices.py

@@ -1,4 +1,4 @@
-from pt_strategy.research_strategy import PtResearchStrategy
+from pairs_trading.lib.pt_strategy.research_strategy import PtResearchStrategy
 
 
 def visualize_prices(strategy: PtResearchStrategy, trading_date: str) -> None: 
@@ -8,8 +8,8 @@ def visualize_prices(strategy: PtResearchStrategy, trading_date: str) -> None:
     import seaborn as sns
 
     pair = strategy.trading_pair_
-    SYMBOL_A = pair.symbol_a_
+    SYMBOL_A = pair.symbol_a()
-    SYMBOL_B = pair.symbol_b_
+    SYMBOL_B = pair.symbol_b()
     TRD_DATE = f"{trading_date[0:4]}-{trading_date[4:6]}-{trading_date[6:8]}"
 
     plt.style.use('seaborn-v0_8')

__SAV__/lib/tools/viz/viz_trades.py

@@ -1,13 +1,8 @@
 from __future__ import annotations
 
-import os
-from typing import Any, Dict
 
-from pt_strategy.results import (PairResearchResult, create_result_database,
+from pairs_trading.lib.pt_strategy.results import (PairResearchResult)
-                                 store_config_in_database)
+from pairs_trading.lib.pt_strategy.research_strategy import PtResearchStrategy
-from pt_strategy.research_strategy import PtResearchStrategy
-from tools.filetools import resolve_datafiles
-from tools.instruments import get_instruments
 
 
 def visualize_trades(strategy: PtResearchStrategy, results: PairResearchResult, trading_date: str) -> None: 
@@ -25,8 +20,8 @@ def visualize_trades(strategy: PtResearchStrategy, results: PairResearchResult,
     origin_mkt_data_df = strategy.pt_mkt_data_.origin_mkt_data_df_
     mkt_data_df = strategy.pt_mkt_data_.market_data_df_
     TRD_DATE = f"{trading_date[0:4]}-{trading_date[4:6]}-{trading_date[6:8]}"
-    SYMBOL_A = pair.symbol_a_
+    SYMBOL_A = pair.symbol_a()
-    SYMBOL_B = pair.symbol_b_
+    SYMBOL_B = pair.symbol_b()
 
     
     print(f"\nCreated trading pair: {pair}")
@@ -51,7 +46,7 @@ def visualize_trades(strategy: PtResearchStrategy, results: PairResearchResult,
     timeline_df = pd.DataFrame({'tstamp': all_timestamps})
 
     # Merge with predicted data to get dis-equilibrium values
-    timeline_df = timeline_df.merge(strategy.predictions_[['tstamp', 'disequilibrium', 'scaled_disequilibrium', 'signed_scaled_disequilibrium']], 
+    timeline_df = timeline_df.merge(strategy.predictions_df_[['tstamp', 'disequilibrium', 'scaled_disequilibrium', 'signed_scaled_disequilibrium']], 
                                     on='tstamp', how='left')
 
     # Get Symbol_A and Symbol_B market data
@@ -110,8 +105,8 @@ def visualize_trades(strategy: PtResearchStrategy, results: PairResearchResult,
         type="line",
         x0=timeline_df['tstamp'].min(),
         x1=timeline_df['tstamp'].max(),
-        y0=strategy.config_['dis-equilibrium_open_trshld'],
+        y0=strategy.config_.get_value('model/disequilibrium/open_trshld'),
-        y1=strategy.config_['dis-equilibrium_open_trshld'],
+        y1=strategy.config_.get_value('model/disequilibrium/open_trshld'),
         line=dict(color="purple", width=2, dash="dot"),
         opacity=0.7,
         row=1, col=1
@@ -121,8 +116,8 @@ def visualize_trades(strategy: PtResearchStrategy, results: PairResearchResult,
         type="line",
         x0=timeline_df['tstamp'].min(),
         x1=timeline_df['tstamp'].max(),
-        y0=-strategy.config_['dis-equilibrium_open_trshld'],
+        y0=-strategy.config_.get_value('model/disequilibrium/open_trshld'),
-        y1=-strategy.config_['dis-equilibrium_open_trshld'],
+        y1=-strategy.config_.get_value('model/disequilibrium/open_trshld'),
         line=dict(color="purple", width=2, dash="dot"),
         opacity=0.7,
         row=1, col=1
@@ -132,8 +127,8 @@ def visualize_trades(strategy: PtResearchStrategy, results: PairResearchResult,
         type="line",
         x0=timeline_df['tstamp'].min(),
         x1=timeline_df['tstamp'].max(),
-        y0=strategy.config_['dis-equilibrium_close_trshld'],
+        y0=strategy.config_.get_value('model/disequilibrium/close_trshld'),
-        y1=strategy.config_['dis-equilibrium_close_trshld'],
+        y1=strategy.config_.get_value('model/disequilibrium/close_trshld'),
         line=dict(color="brown", width=2, dash="dot"),
         opacity=0.7,
         row=1, col=1
@@ -143,8 +138,8 @@ def visualize_trades(strategy: PtResearchStrategy, results: PairResearchResult,
         type="line",
         x0=timeline_df['tstamp'].min(),
         x1=timeline_df['tstamp'].max(),
-        y0=-strategy.config_['dis-equilibrium_close_trshld'],
+        y0=-strategy.config_.get_value('model/disequilibrium/close_trshld'),
-        y1=-strategy.config_['dis-equilibrium_close_trshld'],
+        y1=-strategy.config_.get_value('model/disequilibrium/close_trshld'),
         line=dict(color="brown", width=2, dash="dot"),
         opacity=0.7,
         row=1, col=1

__SAV__/requirements.txt

@@ -0,0 +1,201 @@
+aiohttp>=3.8.4
+aiosignal>=1.3.1
+async-timeout>=4.0.2
+attrs>=21.2.0
+beautifulsoup4>=4.10.0
+black>=23.3.0
+flake8>=6.0.0
+certifi>=2020.6.20
+chardet>=4.0.0
+charset-normalizer>=3.1.0
+click>=8.0.3
+colorama>=0.4.4
+configobj>=5.0.6
+cryptography>=3.4.8
+distro>=1.7.0
+docker>=5.0.3
+dockerpty>=0.4.1
+docopt>=0.6.2
+eyeD3>=0.8.10
+filelock>=3.6.0
+frozenlist>=1.3.3
+grpcio>=1.30.2
+hjson>=3.0.2
+html5lib>=1.1
+httplib2>=0.20.2
+idna>=3.3
+ipython>=8.18.1
+ipywidgets>=8.1.1
+ifaddr>=0.1.7
+IMDbPY>=2021.4.18
+ipykernel>=6.29.5
+jeepney>=0.7.1
+jsonschema>=3.2.0
+jupyter>=1.0.0
+keyring>=23.5.0
+launchpadlib>=1.10.16
+lazr.restfulclient>=0.14.4
+lazr.uri>=1.0.6
+lxml>=4.8.0
+Mako>=1.1.3
+Markdown>=3.3.6
+MarkupSafe>=2.0.1
+matplotlib>=3.10.3
+more-itertools>=8.10.0
+multidict>=6.0.4
+mypy>=0.942
+mypy-extensions>=0.4.3
+nbformat>=5.10.2
+netaddr>=0.8.0
+######### netifaces>=0.11.0
+numpy>=1.26.4,<2.3.0
+oauthlib>=3.2.0
+packaging>=23.1
+pandas>=2.2.3
+pathspec>=0.11.1
+pexpect>=4.8.0
+Pillow>=9.0.1
+platformdirs>=3.2.0
+plotly>=5.19.0
+protobuf>=3.12.4
+psutil>=5.9.0
+ptyprocess>=0.7.0
+pycurl>=7.44.1
+pyelftools>=0.27
+Pygments>=2.11.2
+pyparsing>=2.4.7
+pyrsistent>=0.18.1
+python-debian>=0.1.43 #+ubuntu1.1
+python-dotenv>=0.19.2
+python-magic>=0.4.24
+python-xlib>=0.29
+pyxdg>=0.27
+PyYAML>=6.0
+reportlab>=3.6.8
+requests>=2.25.1
+requests-file>=1.5.1
+scipy<1.13.0
+seaborn>=0.13.2
+SecretStorage>=3.3.1
+setproctitle>=1.2.2
+simpleeval>=1.0.3
+six>=1.16.0
+soupsieve>=2.3.1
+ssh-import-id>=5.11
+statsmodels>=0.14.4
+texttable>=1.6.4
+tldextract>=3.1.2
+tomli>=1.2.2
+######## typed-ast>=1.4.3
+types-aiofiles>=0.1
+types-annoy>=1.17
+types-appdirs>=1.4
+types-atomicwrites>=1.4
+types-aws-xray-sdk>=2.8
+types-babel>=2.9
+types-backports-abc>=0.5
+types-backports.ssl-match-hostname>=3.7
+types-beautifulsoup4>=4.10
+types-bleach>=4.1
+types-boto>=2.49
+types-braintree>=4.11
+types-cachetools>=4.2
+types-caldav>=0.8
+types-certifi>=2020.4
+types-characteristic>=14.3
+types-chardet>=4.0
+types-click>=7.1
+types-click-spinner>=0.1
+types-colorama>=0.4
+types-commonmark>=0.9
+types-contextvars>=0.1
+types-croniter>=1.0
+types-cryptography>=3.3
+types-dataclasses>=0.1
+types-dateparser>=1.0
+types-DateTimeRange>=0.1
+types-decorator>=0.1
+types-Deprecated>=1.2
+types-docopt>=0.6
+types-docutils>=0.17
+types-editdistance>=0.5
+types-emoji>=1.2
+types-entrypoints>=0.3
+types-enum34>=1.1
+types-filelock>=3.2
+types-first>=2.0
+types-Flask>=1.1
+types-freezegun>=1.1
+types-frozendict>=0.1
+types-futures>=3.3
+types-html5lib>=1.1
+types-httplib2>=0.19
+types-humanfriendly>=9.2
+types-ipaddress>=1.0
+types-itsdangerous>=1.1
+types-JACK-Client>=0.1
+types-Jinja2>=2.11
+types-jmespath>=0.10
+types-jsonschema>=3.2
+types-Markdown>=3.3
+types-MarkupSafe>=1.1
+types-mock>=4.0
+types-mypy-extensions>=0.4
+types-mysqlclient>=2.0
+types-oauthlib>=3.1
+types-orjson>=3.6
+types-paramiko>=2.7
+types-Pillow>=8.3
+types-polib>=1.1
+types-prettytable>=2.1
+types-protobuf>=3.17
+types-psutil>=5.8
+types-psycopg2>=2.9
+types-pyaudio>=0.2
+types-pycurl>=0.1
+types-pyfarmhash>=0.2
+types-Pygments>=2.9
+types-PyMySQL>=1.0
+types-pyOpenSSL>=20.0
+types-pyRFC3339>=0.1
+types-pysftp>=0.2
+types-pytest-lazy-fixture>=0.6
+types-python-dateutil>=2.8
+types-python-gflags>=3.1
+types-python-nmap>=0.6
+types-python-slugify>=5.0
+types-pytz>=2021.1
+types-pyvmomi>=7.0
+types-PyYAML>=5.4
+types-redis>=3.5
+types-requests>=2.25
+types-retry>=0.9
+types-seaborn>0.13.2
+types-selenium>=3.141
+types-Send2Trash>=1.8
+types-setuptools>=57.4
+types-simplejson>=3.17
+types-singledispatch>=3.7
+types-six>=1.16
+types-slumber>=0.7
+types-stripe>=2.59
+types-tabulate>=0.8
+types-termcolor>=1.1
+types-toml>=0.10
+types-toposort>=1.6
+types-ttkthemes>=3.2
+types-typed-ast>=1.4
+types-tzlocal>=0.1
+types-ujson>=0.1
+types-vobject>=0.9
+types-waitress>=0.1
+types-Werkzeug>=1.0
+types-xxhash>=2.0
+typing-extensions>=3.10.0.2
+Unidecode>=1.3.3
+urllib3>=1.26.5
+wadllib>=1.3.6
+webencodings>=0.5.1
+websocket-client>=1.2.3
+yarl>=1.9.1
+zipp>=1.0.0

__SAV__/research/backtest.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, List, Tuple
+
+# ---
+from cvttpy_tools.base.app import App
+from cvttpy_tools.base.base import NamedObject
+from cvttpy_tools.base.config import CvttAppConfig
+
+# ---
+from cvttpy_trading.trading.instrument import ExchangeInstrument
+from cvttpy_trading.settings.instruments import Instruments
+
+# ---
+from pairs_trading.lib.pt_strategy.results import (
+    PairResearchResult,
+    create_result_database,
+    store_config_in_database,
+)
+from pairs_trading.lib.pt_strategy.research_strategy import PtResearchStrategy
+from pairs_trading.lib.tools.filetools import resolve_datafiles
+
+InstrumentTypeT = str
+
+
+class Runner(NamedObject):
+    def __init__(self):
+        App()
+        CvttAppConfig()
+
+        # App.instance().add_cmdline_arg(
+        #     "--config", type=str, required=True, help="Path to the configuration file."
+        # )
+        App.instance().add_cmdline_arg(
+            "--date_pattern",
+            type=str,
+            required=True,
+            help="Date YYYYMMDD, allows * and ? wildcards",
+        )
+        App.instance().add_cmdline_arg(
+            "--instruments",
+            type=str,
+            required=True,
+            help="Comma-separated list of instrument symbols (e.g., COIN:EQUITY,GBTC:CRYPTO)",
+        )
+        App.instance().add_cmdline_arg(
+            "--result_db",
+            type=str,
+            required=True,
+            help="Path to SQLite database for storing results. Use 'NONE' to disable database output.",
+        )
+
+        App.instance().add_call(stage=App.Stage.Config, func=self._on_config())
+        App.instance().add_call(stage=App.Stage.Run, func=self.run())
+
+    async def _on_config(self) -> None:
+        # Resolve data files (CLI takes priority over config)
+        instruments: List[ExchangeInstrument] = self._get_instruments()
+        datafiles = resolve_datafiles(
+            config=CvttAppConfig.instance(),
+            date_pattern=App.instance().get_argument("date_pattern"),
+            instruments=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 App.instance().get_argument("result_db").upper() != "NONE":
+            create_result_database(App.instance().get_argument("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=CvttAppConfig.instance())
+        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}")
+                exit(1)
+            print(f"\n====== Processing {day} ======")
+
+            if not is_config_stored:
+                store_config_in_database(
+                    db_path=App.instance().get_argument("result_db"),
+                    config_file_path=App.instance().get_argument("config"),
+                    config=CvttAppConfig.instance(),
+                    datafiles=datafiles,
+                    instruments=instruments,
+                )
+                is_config_stored = True
+
+            CvttAppConfig.instance().set_value("datafiles", md_datafiles)
+            pt_strategy = PtResearchStrategy(
+                config=CvttAppConfig.instance(),
+                instruments=instruments,
+            )
+            pt_strategy.run()
+            results.add_day_results(
+                day=day,
+                trades=pt_strategy.day_trades(),
+                outstanding_positions=pt_strategy.outstanding_positions(),
+            )
+
+        results.analyze_pair_performance()
+
+    def _get_instruments(self) -> List[ExchangeInstrument]:
+        res: List[ExchangeInstrument] = []
+
+        for inst in App.instance().get_argument("instruments").split(","):
+            instrument_type = inst.split(":")[0]
+            exchange_id = inst.split(":")[1]
+            instrument_id = inst.split(":")[2]
+            exch_inst: ExchangeInstrument = Instruments.instance().get_exch_inst(
+                exch_id=exchange_id, inst_id=instrument_id, src=f"{self.fname()}"
+            )
+            exch_inst.user_data_["instrument_type"] = instrument_type
+            res.append(exch_inst)
+
+        return res
+
+    async def run(self) -> None:
+
+        if App.instance().get_argument("result_db").upper() != "NONE":
+            print(
+                f'\nResults stored in database: {App.instance().get_argument("result_db")}'
+            )
+        else:
+            print("No results to display.")
+
+
+if __name__ == "__main__":
+    Runner()
+    App.instance().run()

__SAV__/research/notebooks/pair_select_hist.ipynb

@@ -0,0 +1,311 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Pair Selection History\n",
+        "\n",
+        "Interactive notebook for exploring pair selection history from a SQLite database.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "**Usage**\n",
+        "- Enter the SQLite `db_path` (file path).\n",
+        "- Click `Load pairs` to populate the dropdown.\n",
+        "- Select a `pair_name`, then click `Plot`.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "668ebf19",
+      "metadata": {},
+      "source": [
+        "# Settings"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "c78db847",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import sqlite3\n",
+        "from pathlib import Path\n",
+        "\n",
+        "import pandas as pd\n",
+        "import plotly.express as px\n",
+        "import ipywidgets as widgets\n",
+        "from IPython.display import display\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "e7ac6adc",
+      "metadata": {},
+      "source": [
+        "# Data Loading"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "766bcf9f",
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "e0b30b1abd1b440b832fdaaa6cce8f76",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "VBox(children=(Text(value='', description='pair_db', layout=Layout(width='80%'), placeholder='/path/to/pairs.d…"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "15679f9015854d5fa7119210094fbbc8",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "Output()"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "db_path = widgets.Text(\n",
+        "    value='',\n",
+        "    placeholder='/path/to/pairs.db',\n",
+        "    description='pair_db',\n",
+        "    layout=widgets.Layout(width='80%')\n",
+        ")\n",
+        "\n",
+        "md_db_path = widgets.Text(\n",
+        "    value='',\n",
+        "    placeholder='/path/to/market_data.db',\n",
+        "    description='md_db',\n",
+        "    layout=widgets.Layout(width='80%')\n",
+        ")\n",
+        "\n",
+        "load_button = widgets.Button(description='Load pairs', button_style='info')\n",
+        "plot_button = widgets.Button(description='Plot', button_style='primary')\n",
+        "\n",
+        "pair_name = widgets.Dropdown(\n",
+        "    options=[],\n",
+        "    value=None,\n",
+        "    description='pair_name',\n",
+        "    layout=widgets.Layout(width='80%')\n",
+        ")\n",
+        "\n",
+        "status = widgets.HTML(value='')\n",
+        "output = widgets.Output()\n",
+        "\n",
+        "controls = widgets.VBox([\n",
+        "    db_path,\n",
+        "    md_db_path,\n",
+        "    widgets.HBox([load_button, plot_button]),\n",
+        "    pair_name,\n",
+        "    status,\n",
+        "])\n",
+        "\n",
+        "display(controls, output)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "a4d47855",
+      "metadata": {},
+      "source": [
+        "# Processing"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "2c710f51",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "PLOT_WIDTH = 1100\n",
+        "PLOT_HEIGHT = 320\n",
+        "\n",
+        "def _connect(path: str):\n",
+        "    if not path:\n",
+        "        raise ValueError('Please provide db_path.')\n",
+        "    p = Path(path).expanduser().resolve()\n",
+        "    if not p.exists():\n",
+        "        raise FileNotFoundError(f'Database not found: {p}')\n",
+        "    return sqlite3.connect(p)\n",
+        "\n",
+        "\n",
+        "def _parse_tstamp(series: pd.Series) -> pd.Series:\n",
+        "    return pd.to_datetime(series, utc=True, errors='coerce').dt.tz_convert(None)\n",
+        "\n",
+        "\n",
+        "def _style_fig(fig, tmin, tmax):\n",
+        "    fig.update_layout(\n",
+        "        legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='left', x=0),\n",
+        "        margin=dict(l=50, r=20, t=60, b=40),\n",
+        "        height=PLOT_HEIGHT,\n",
+        "        width=PLOT_WIDTH,\n",
+        "    )\n",
+        "    fig.update_xaxes(range=[tmin, tmax])\n",
+        "\n",
+        "\n",
+        "def _load_pairs(_=None):\n",
+        "    status.value = ''\n",
+        "    with output:\n",
+        "        output.clear_output()\n",
+        "    try:\n",
+        "        with _connect(db_path.value) as conn:\n",
+        "            rows = conn.execute(\n",
+        "                \"SELECT pair_name \"\n",
+        "                \"FROM pair_selection_history \"\n",
+        "                \"GROUP BY pair_name \"\n",
+        "                \"ORDER BY SUM(composite_rank), pair_name\"\n",
+        "            ).fetchall()\n",
+        "        options = [r[0] for r in rows]\n",
+        "        pair_name.options = options\n",
+        "        pair_name.value = options[0] if options else None\n",
+        "        status.value = f'Loaded {len(options)} pairs.'\n",
+        "    except Exception as exc:\n",
+        "        status.value = f\"<span style='color:#b00'>Error: {exc}</span>\"\n",
+        "\n",
+        "\n",
+        "def _plot(_=None):\n",
+        "    status.value = ''\n",
+        "    with output:\n",
+        "        output.clear_output()\n",
+        "    try:\n",
+        "        if not pair_name.value:\n",
+        "            raise ValueError('Please select a pair_name.')\n",
+        "        if not md_db_path.value:\n",
+        "            raise ValueError('Please provide md_db path.')\n",
+        "        query = (\n",
+        "            'SELECT tstamp, pvalue_eg, pvalue_adf, rank_eg, rank_adf, '\n",
+        "            'exchange_a, instrument_a, exchange_b, instrument_b '\n",
+        "            'FROM pair_selection_history '\n",
+        "            'WHERE pair_name = ? '\n",
+        "            'ORDER BY tstamp'\n",
+        "        )\n",
+        "        with _connect(db_path.value) as conn:\n",
+        "            df = pd.read_sql_query(query, conn, params=(pair_name.value,))\n",
+        "        if df.empty:\n",
+        "            raise ValueError('No data for selected pair_name.')\n",
+        "        df['tstamp'] = _parse_tstamp(df['tstamp'])\n",
+        "        df = df.dropna(subset=['tstamp'])\n",
+        "        if df.empty:\n",
+        "            raise ValueError('No valid timestamps in pair selection data.')\n",
+        "        tmin = df['tstamp'].min()\n",
+        "        tmax = df['tstamp'].max()\n",
+        "\n",
+        "        first_row = df.dropna(subset=['exchange_a', 'instrument_a', 'exchange_b', 'instrument_b']).iloc[0]\n",
+        "        ex_a = first_row['exchange_a']\n",
+        "        id_a = first_row['instrument_a']\n",
+        "        ex_b = first_row['exchange_b']\n",
+        "        id_b = first_row['instrument_b']\n",
+        "\n",
+        "        fig_p = px.line(\n",
+        "            df,\n",
+        "            x='tstamp',\n",
+        "            y=['pvalue_eg', 'pvalue_adf'],\n",
+        "            title=f'P-Values Over Time: {pair_name.value}',\n",
+        "            labels={'value': 'p-value', 'variable': 'metric', 'tstamp': 'timestamp'}\n",
+        "        )\n",
+        "        fig_p.update_layout(legend_title_text='metric')\n",
+        "        _style_fig(fig_p, tmin, tmax)\n",
+        "\n",
+        "                md_query = (\n",
+        "            'SELECT tstamp, close FROM md_1min_bars '\n",
+        "            'WHERE exchange_id = ? AND instrument_id = ? '\n",
+        "            'ORDER BY tstamp'\n",
+        "        )\n",
+        "        with _connect(md_db_path.value) as md_conn:\n",
+        "            md_a = pd.read_sql_query(md_query, md_conn, params=(ex_a, id_a))\n",
+        "            md_b = pd.read_sql_query(md_query, md_conn, params=(ex_b, id_b))\n",
+        "        if md_a.empty or md_b.empty:\n",
+        "            raise ValueError('Market data not found for selected instruments.')\n",
+        "        md_a['tstamp'] = _parse_tstamp(md_a['tstamp'])\n",
+        "        md_b['tstamp'] = _parse_tstamp(md_b['tstamp'])\n",
+        "        md_a = md_a.dropna(subset=['tstamp', 'close'])\n",
+        "        md_b = md_b.dropna(subset=['tstamp', 'close'])\n",
+        "        md_a = md_a[(md_a['tstamp'] >= tmin) & (md_a['tstamp'] <= tmax)]\n",
+        "        md_b = md_b[(md_b['tstamp'] >= tmin) & (md_b['tstamp'] <= tmax)]\n",
+        "        if md_a.empty or md_b.empty:\n",
+        "            raise ValueError('Market data is outside the pair selection time range.')\n",
+        "        md_a = md_a.sort_values('tstamp')\n",
+        "        md_b = md_b.sort_values('tstamp')\n",
+        "        md_a['scaled_close'] = (md_a['close'] - md_a['close'].iloc[0]) / md_a['close'].iloc[0] * 100\n",
+        "        md_b['scaled_close'] = (md_b['close'] - md_b['close'].iloc[0]) / md_b['close'].iloc[0] * 100\n",
+        "\n",
+        "        md_plot = pd.DataFrame({\n",
+        "            'tstamp': md_a['tstamp'],\n",
+        "            f'{ex_a}:{id_a}': md_a['scaled_close'],\n",
+        "        })\n",
+        "        md_plot = md_plot.merge(\n",
+        "            pd.DataFrame({\n",
+        "                'tstamp': md_b['tstamp'],\n",
+        "                f'{ex_b}:{id_b}': md_b['scaled_close'],\n",
+        "            }),\n",
+        "            on='tstamp',\n",
+        "            how='outer'\n",
+        "        ).sort_values('tstamp')\n",
+        "\n",
+        "        fig_m = px.line(\n",
+        "            md_plot,\n",
+        "            x='tstamp',\n",
+        "            y=[f'{ex_a}:{id_a}', f'{ex_b}:{id_b}'],\n",
+        "            title='Scaled Close Price Change (%)',\n",
+        "            labels={'value': 'scaled % change', 'variable': 'instrument', 'tstamp': 'timestamp'}\n",
+        "        )\n",
+        "        fig_m.update_layout(legend_title_text='instrument')\n",
+        "        _style_fig(fig_m, tmin, tmax)\n",
+        "\n",
+        "        with output:\n",
+        "            display(fig_p)\n",
+        "            display(fig_m)\n",
+        "    except Exception as exc:\n",
+        "        status.value = f\"<span style='color:#b00'>Error: {exc}</span>\"\n",
+        "\n",
+        "\n",
+        "load_button.on_click(_load_pairs)\n",
+        "plot_button.on_click(_plot)\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "python3.12-venv",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.12.9"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

bin/pairs_trader.py

@@ -1,105 +0,0 @@
-from __future__ import annotations
-
-from functools import partial
-from typing import Dict, List
-
-from cvttpy_tools.settings.cvtt_types import JsonDictT
-from cvttpy_tools.tools.app import App
-from cvttpy_tools.tools.base import NamedObject
-from cvttpy_tools.tools.config import CvttAppConfig
-from cvttpy_tools.tools.logger import Log
-from pt_strategy.live.live_strategy import PtLiveStrategy
-from pt_strategy.live.pricer_md_client import PtMktDataClient
-from pt_strategy.live.ti_sender import TradingInstructionsSender
-
-# import sys
-# print("PYTHONPATH directories:")
-# for path in sys.path:
-#     print(path)
-
-
-
-# from cvtt_client.mkt_data import (CvttPricerWebSockClient,
-#                                   CvttPricesSubscription, MessageTypeT,
-#                                   SubscriptionIdT)
-
-class PairTradingRunner(NamedObject):
-    config_: CvttAppConfig
-    instruments_: List[JsonDictT]
-
-    live_strategy_: PtLiveStrategy
-    pricer_client_: PtMktDataClient
-    
-    def __init__(self) -> None:
-        self.instruments_ = []
-        
-        App.instance().add_cmdline_arg(
-            "--pair",
-            type=str,
-            required=True,
-            help=(
-                "Comma-separated pair of instrument symbols"
-                " with exchange config name"
-                " (e.g., PAIR-BTC-USD:BNBSPOT,PAIR-ETH-USD:BNBSPOT)"
-            ),
-        )
-
-        App.instance().add_call(App.Stage.Config, self._on_config())
-        App.instance().add_call(App.Stage.Run, self.run())
-        
-    async def _on_config(self) -> None:
-        self.config_ = CvttAppConfig.instance()
-        
-        # ------- PARSE INSTRUMENTS -------
-        instr_str = App.instance().get_argument("pair", "")
-        if not instr_str:
-            raise ValueError("Pair is required")
-        instr_list = instr_str.split(",")
-        for instr in instr_list:
-            instr_parts = instr.split(":")
-            if len(instr_parts) != 2:
-                raise ValueError(f"Invalid pair format: {instr}")   
-            instrument_id = instr_parts[0]
-            exchange_config_name = instr_parts[1]
-            self.instruments_.append({
-                "exchange_config_name": exchange_config_name,
-                "instrument_id": instrument_id
-            })  
-            
-        assert len(self.instruments_) == 2, "Only two instruments are supported"        
-        Log.info(f"{self.fname()} Instruments: {self.instruments_}")
-        
-        # ------- CREATE TI (trading instructions) CLIENT -------
-        ti_config = self.config_.get_subconfig("ti_config", {})
-        self.ti_sender_ = TradingInstructionsSender(config=ti_config)
-        Log.info(f"{self.fname()} TI client created: {self.ti_sender_}")  
-        
-        # ------- CREATE STRATEGY -------
-        strategy_config = self.config_.get_value("strategy_config", {})
-        self.live_strategy_ = PtLiveStrategy(
-            config=strategy_config,
-            instruments=self.instruments_,
-            ti_sender=self.ti_sender_
-        )
-        Log.info(f"{self.fname()} Strategy created: {self.live_strategy_}")  
-        
-        # ------- CREATE PRICER CLIENT -------
-        pricer_config = self.config_.get_subconfig("pricer_config", {})
-        self.pricer_client_ = PtMktDataClient(
-            live_strategy=self.live_strategy_,
-            pricer_config=pricer_config
-        )
-        Log.info(f"{self.fname()} CVTT Pricer client created: {self.pricer_client_}")  
-
-    async def run(self) -> None:
-        Log.info(f"{self.fname()} ...")
-        pass
-
-    
-
-
-if __name__ == "__main__":
-    App()
-    CvttAppConfig()
-    PairTradingRunner()
-    App.instance().run()

configuration/ols-exp.cfg

@@ -1,43 +0,0 @@
-{
-    "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.OLSModel",
-    "model_data_policy_class": "pt_strategy.model_data_policy.ExpandingWindowDataPolicy",
-
-    # ====== 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",
-    }
-}

configuration/ols-opt.cfg

@@ -1,47 +0,0 @@
-{
-    "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": 1.75,
-    "dis-equilibrium_close_trshld": 0.9,
-    "model_class": "pt_strategy.models.OLSModel",
-
-    # "model_data_policy_class": "pt_strategy.model_data_policy.EGOptimizedWndDataPolicy",
-    # "model_data_policy_class": "pt_strategy.model_data_policy.ADFOptimizedWndDataPolicy",
-    "model_data_policy_class": "pt_strategy.model_data_policy.JohansenOptdWndDataPolicy",
-    "min_training_size": 60,
-    "max_training_size": 150,
-
-    # ====== 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",
-    }
-}

configuration/vecm-opt.cfg

@@ -1,49 +0,0 @@
-{
-    "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", # "vwap"
-    "execution_price": {
-        "column": "vwap",
-        "shift": 1,
-    },
-    "dis-equilibrium_open_trshld": 1.75,
-    "dis-equilibrium_close_trshld": 1.0,
-
-    "model_class": "pt_strategy.models.VECMModel",
-
-    # "training_size": 120,
-    # "model_data_policy_class": "pt_strategy.model_data_policy.RollingWindowDataPolicy",
-    "model_data_policy_class": "pt_strategy.model_data_policy.ADFOptimizedWndDataPolicy",
-    "min_training_size": 60,
-    "max_training_size": 150,
-
-    # ====== 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",
-    }
-}

configuration/vecm.cfg

@@ -1,48 +0,0 @@
-{
-    "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", # "vwap"
-    "execution_price": {
-        "column": "vwap",
-        "shift": 1,
-    },
-    "dis-equilibrium_open_trshld": 1.75,
-    "dis-equilibrium_close_trshld": 1.0,
-    "model_class": "pt_strategy.models.VECMModel",
-
-    "training_size": 120,
-    "model_data_policy_class": "pt_strategy.model_data_policy.RollingWindowDataPolicy",
-    # "model_data_policy_class": "pt_strategy.model_data_policy.OptimizedWindowDataPolicy",
-    # "min_training_size": 60,
-    # "max_training_size": 150,
-
-    # ====== 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",
-    }
-}

lib/cvtt_client/mkt_data.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-
-import asyncio
-import json
-import uuid
-from dataclasses import dataclass
-from functools import partial
-from typing import Callable, Coroutine, Dict, Optional
-
-import websockets
-from cvttpy_tools.settings.cvtt_types import JsonDictT
-from cvttpy_tools.tools.logger import Log
-from websockets.asyncio.client import ClientConnection
-
-MessageTypeT = str
-SubscriptionIdT = str
-MessageT = Dict
-UrlT = str
-CallbackT = Callable[[MessageTypeT, SubscriptionIdT, MessageT], Coroutine[None, str, None]]
-
-@dataclass
-class CvttPricesSubscription:
-    id_: str
-    exchange_config_name_: str
-    instrument_id_: str
-    interval_sec_: int
-    history_depth_sec_: int
-    is_subscribed_: bool
-    is_historical_: bool
-    callback_: CallbackT
-
-    def __init__(
-        self,
-        exchange_config_name: str,
-        instrument_id: str,
-        interval_sec: int,
-        history_depth_sec: int,
-        callback: CallbackT,
-    ):
-        self.exchange_config_name_ = exchange_config_name
-        self.instrument_id_ = instrument_id
-        self.interval_sec_ = interval_sec
-        self.history_depth_sec_ = history_depth_sec
-        self.callback_ = callback
-        self.id_ = str(uuid.uuid4())
-        self.is_subscribed_ = False
-        self.is_historical_ = history_depth_sec > 0
-
-class CvttWebSockClient:
-    ws_url_: UrlT
-    websocket_: Optional[ClientConnection]
-    is_connected_: bool
-    
-    def __init__(self, url: str):
-        self.ws_url_ = url
-        self.websocket_ = None
-        self.is_connected_ = False
-
-    async def connect(self) -> None:
-        self.websocket_ = await websockets.connect(self.ws_url_)
-        self.is_connected_ = True
-
-    async def close(self) -> None:
-        if self.websocket_ is not None:
-            await self.websocket_.close()
-            self.is_connected_ = False
-
-    async def receive_message(self) -> JsonDictT:
-        assert self.websocket_ is not None
-        assert self.is_connected_
-        message = await self.websocket_.recv()
-        message_str = (
-            message.decode("utf-8")
-            if isinstance(message, bytes)
-            else message
-        )
-        res = json.loads(message_str)
-        assert res is not None
-        assert isinstance(res, dict)
-        return res
-    
-    @classmethod
-    async def check_connection(cls, url: str) -> bool:
-        try:
-            async with websockets.connect(url) as websocket:
-                result = True
-        except Exception as e:
-            Log.error(f"Unable to connect to {url}: {str(e)}")
-            result = False
-        return result
-    
-class CvttPricerWebSockClient(CvttWebSockClient):
-    # Class members with type hints
-    subscriptions_: Dict[SubscriptionIdT, CvttPricesSubscription]
-
-    def __init__(self, url: str):
-        super().__init__(url)
-        self.subscriptions_ = {}
-
-    async def subscribe(
-        self, subscription: CvttPricesSubscription
-    ) -> str:  # returns subscription id
-
-        if not self.is_connected_:
-            try:
-                Log.info(f"Connecting to {self.ws_url_}")
-                await self.connect()
-            except Exception as e:
-                Log.error(f"Unable to connect to {self.ws_url_}: {str(e)}")
-                raise e
-
-        subscr_msg = {
-            "type": "subscr",
-            "id": subscription.id_,
-            "subscr_type": "MD_AGGREGATE",
-            "exchange_config_name": subscription.exchange_config_name_,
-            "instrument_id": subscription.instrument_id_,
-            "interval_sec": subscription.interval_sec_,
-        }
-        if subscription.is_historical_:
-            subscr_msg["history_depth_sec"] = subscription.history_depth_sec_
-
-        assert self.websocket_ is not None
-        await self.websocket_.send(json.dumps(subscr_msg))
-
-        response = await self.websocket_.recv()
-        response_data = json.loads(response)
-        if not await self.handle_subscription_response(subscription, response_data):
-            await self.websocket_.close()
-            self.is_connected_ = False
-            raise Exception(f"Subscription failed: {str(response)}")
-
-        self.subscriptions_[subscription.id_] = subscription
-        return subscription.id_
-
-    async def handle_subscription_response(
-        self, subscription: CvttPricesSubscription, response: dict
-    ) -> bool:
-        if response.get("type") != "subscr" or response.get("id") != subscription.id_:
-            return False
-
-        if response.get("status") == "success":
-            Log.info(f"Subscription successful: {json.dumps(response)}")
-            return True
-        elif response.get("status") == "error":
-            Log.error(f"Subscription failed: {response.get('reason')}")
-            return False
-        return False
-
-    async def run(self) -> None:
-        assert self.websocket_
-        try:
-            while self.is_connected_:
-                try:
-                    msg_dict: JsonDictT = await self.receive_message()
-                except websockets.ConnectionClosed:
-                    Log.warning("Connection closed")
-                    self.is_connected_ = False
-                    break
-                except Exception as e:
-                    Log.error(f"Error occurred: {str(e)}")
-                    self.is_connected_ = False
-                    await asyncio.sleep(5)  # Wait before reconnecting
-
-                await self.process_message(msg_dict)
-
-        except Exception as e:
-            Log.error(f"Error occurred: {str(e)}")
-            self.is_connected_ = False
-            await asyncio.sleep(5)  # Wait before reconnecting
-
-    async def process_message(self, message: Dict) -> None:
-        message_type = message.get("type")
-        if message_type in ["md_aggregate", "historical_md_aggregate"]:
-            subscription_id = message.get("subscr_id")
-            if subscription_id not in self.subscriptions_:
-                Log.warning(f"Unknown subscription id: {subscription_id}")
-                return
-
-            subscription = self.subscriptions_[subscription_id]
-            await subscription.callback_(message_type, subscription_id, message)
-        else:
-            Log.warning(f"Unknown message type: {message.get('type')}")
-
-
-async def main() -> None:
-    async def on_message(message_type: MessageTypeT, subscr_id: SubscriptionIdT, message: Dict, instrument_id: str) -> None:
-        print(f"{message_type=} {subscr_id=} {instrument_id}")
-        if message_type == "md_aggregate":
-            aggr = message.get("md_aggregate", [])
-            print(f"[{aggr['tstamp'][:19]}] *** RLTM ***  {message}")
-        elif message_type == "historical_md_aggregate":
-            for aggr in message.get("historical_data", []):
-                print(f"[{aggr['tstamp'][:19]}] *** HIST *** {aggr}")
-        else:
-            print(f"Unknown message type: {message_type}")
-        
-    pricer_client = CvttPricerWebSockClient(
-        "ws://localhost:12346/ws"
-    )
-    await pricer_client.subscribe(CvttPricesSubscription(
-        exchange_config_name="COINBASE_AT",
-        instrument_id="PAIR-BTC-USD",
-        interval_sec=60,
-        history_depth_sec=60*60*24,
-        callback=partial(on_message, instrument_id="PAIR-BTC-USD")
-    ))
-    await pricer_client.subscribe(CvttPricesSubscription(
-        exchange_config_name="COINBASE_AT",
-        instrument_id="PAIR-ETH-USD",
-        interval_sec=60,
-        history_depth_sec=60*60*24,
-        callback=partial(on_message, instrument_id="PAIR-ETH-USD")
-    ))
-
-    await pricer_client.run() 
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

lib/pt_strategy/live/live_strategy.py

@@ -1,346 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
-
-import pandas as pd
-from cvttpy_tools.settings.cvtt_types import JsonDictT
-from cvttpy_tools.tools.base import NamedObject
-from cvttpy_tools.tools.logger import Log
-from pt_strategy.live.ti_sender import TradingInstructionsSender
-from pt_strategy.model_data_policy import ModelDataPolicy
-from pt_strategy.pt_market_data import RealTimeMarketData
-from pt_strategy.pt_model import Prediction
-from pt_strategy.trading_pair import PairState, TradingPair
-
-"""
-  --config=pair.cfg
-  --pair=PAIR-BTC-USDT:COINBASE_AT,PAIR-ETH-USDT:COINBASE_AT
-"""
-
-
-class TradingInstructionType(Enum):
-    TARGET_POSITION = "TARGET_POSITION"
-
-@dataclass
-class TradingInstruction(NamedObject):
-    type_: TradingInstructionType
-    exch_instr_: ExchangeInstrument
-    specifics_: Dict[str, Any]
-
-
-class PtLiveStrategy(NamedObject):
-    config_: Dict[str, Any]
-    trading_pair_: TradingPair
-    model_data_policy_: ModelDataPolicy
-    pt_mkt_data_: RealTimeMarketData
-    ti_sender_: TradingInstructionsSender
-
-    # for presentation: history of prediction values and trading signals
-    predictions_: pd.DataFrame
-    trading_signals_: pd.DataFrame
-
-    def __init__(
-        self,
-        config: Dict[str, Any],
-        instruments: List[Dict[str, str]],
-        ti_sender: TradingInstructionsSender,
-    ):
-
-        self.config_ = config
-        self.trading_pair_ = TradingPair(config=config, instruments=instruments)
-        self.predictions_ = pd.DataFrame()
-        self.trading_signals_ = pd.DataFrame()
-        self.ti_sender_ = ti_sender
-
-        import copy
-
-        # modified config must be passed to PtMarketData
-        config_copy = copy.deepcopy(config)
-        config_copy["instruments"] = instruments
-        self.pt_mkt_data_ = RealTimeMarketData(config=config_copy)
-        self.model_data_policy_ = ModelDataPolicy.create(
-            config, is_real_time=True, pair=self.trading_pair_
-        )
-        self.open_threshold_ = self.config_.get("dis-equilibrium_open_trshld", 0.0)
-        assert self.open_threshold_ > 0, "open_threshold must be greater than 0"
-        self.close_threshold_ = self.config_.get("dis-equilibrium_close_trshld", 0.0)
-        assert self.close_threshold_ > 0, "close_threshold must be greater than 0"
-
-    def __repr__(self) -> str:
-        return f"{self.classname()}: trading_pair={self.trading_pair_}, mdp={self.model_data_policy_.__class__.__name__}, "
-
-    async def on_mkt_data_hist_snapshot(self, aggr: JsonDictT) -> None:
-        Log.info(f"on_mkt_data_hist_snapshot: {aggr}")
-        await self.pt_mkt_data_.on_mkt_data_hist_snapshot(snapshot=aggr)
-        pass
-
-    async def on_mkt_data_update(self, aggr: JsonDictT) -> None:
-        market_data_df = await self.pt_mkt_data_.on_mkt_data_update(update=aggr)
-        if market_data_df is not None:
-            self.trading_pair_.market_data_ = market_data_df
-            self.model_data_policy_.advance()
-            prediction = self.trading_pair_.run(
-                market_data_df, self.model_data_policy_.advance()
-            )
-            self.predictions_ = pd.concat(
-                [self.predictions_, prediction.to_df()], ignore_index=True
-            )
-
-            trading_instructions: List[TradingInstruction] = (
-                self._create_trading_instructions(
-                    prediction=prediction, last_row=market_data_df.iloc[-1]
-                )
-            )
-            if len(trading_instructions) > 0:
-                await self._send_trading_instructions(trading_instructions)
-            # trades = self._create_trades(prediction=prediction, last_row=market_data_df.iloc[-1])
-        # URGENT implement this
-        pass
-
-    async def _send_trading_instructions(
-        self, trading_instructions: pd.DataFrame
-    ) -> None:
-        pass
-
-    def _create_trading_instructions(
-        self, prediction: Prediction, last_row: pd.Series
-    ) -> List[TradingInstruction]:
-        pair = self.trading_pair_
-        trd_instructions: List[TradingInstruction] = []
-
-        scaled_disequilibrium = prediction.scaled_disequilibrium_
-        abs_scaled_disequilibrium = abs(scaled_disequilibrium)
-
-        if pair.is_closed():
-            if abs_scaled_disequilibrium >= self.open_threshold_:
-                trd_instructions = self._create_open_trade_instructions(
-                    pair, row=last_row, prediction=prediction
-                )
-        elif pair.is_open():
-            if abs_scaled_disequilibrium <= self.close_threshold_:
-                trd_instructions = self._create_close_trade_instructions(
-                    pair, row=last_row, prediction=prediction
-                )
-            elif pair.to_stop_close_conditions(predicted_row=last_row):
-                trd_instructions = self._create_close_trade_instructions(
-                    pair, row=last_row
-                )
-
-        return trd_instructions
-
-    def _create_open_trade_instructions(
-        self, pair: TradingPair, row: pd.Series, prediction: Prediction
-    ) -> List[TradingInstruction]:
-        scaled_disequilibrium = prediction.scaled_disequilibrium_
-
-        if scaled_disequilibrium > 0:
-            side_a = "SELL"
-            trd_inst_a = TradingInstruction(
-                type=TradingInstructionType.TARGET_POSITION,
-                exch_instr=pair.get_instrument_a(),
-                specifics={"side": "SELL", "strength": -1},
-            )
-            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 _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

lib/pt_strategy/live/pricer_md_client.py

@@ -1,85 +0,0 @@
-from __future__ import annotations
-
-from functools import partial
-from typing import Dict, List
-
-from cvtt_client.mkt_data import (CvttPricerWebSockClient,
-                                  CvttPricesSubscription, MessageTypeT,
-                                  SubscriptionIdT)
-from cvttpy_tools.settings.cvtt_types import JsonDictT
-from cvttpy_tools.tools.app import App
-from cvttpy_tools.tools.base import NamedObject
-from cvttpy_tools.tools.config import Config
-from cvttpy_tools.tools.logger import Log
-from pt_strategy.live.live_strategy import PtLiveStrategy
-from pt_strategy.trading_pair import TradingPair
-
-"""
-  --config=pair.cfg
-  --pair=PAIR-BTC-USDT:COINBASE_AT,PAIR-ETH-USDT:COINBASE_AT
-"""
-
-
-class PtMktDataClient(NamedObject):
-    config_: Config
-    live_strategy_: PtLiveStrategy
-    pricer_client_: CvttPricerWebSockClient
-    subscriptions_: List[CvttPricesSubscription]
-
-    def __init__(self, live_strategy: PtLiveStrategy, pricer_config: Config):
-        self.config_ = pricer_config
-        self.live_strategy_ = live_strategy
-
-        App.instance().add_call(App.Stage.Start, self._on_start())
-        App.instance().add_call(App.Stage.Run, self.run())
-
-    async def _on_start(self) -> None:
-        pricer_url = self.config_.get_value("pricer_url")
-        assert pricer_url is not None, "pricer_url is not found in config"
-        self.pricer_client_ = CvttPricerWebSockClient(url=pricer_url)
-
-
-    async def _subscribe(self) -> None:
-        history_depth_sec = self.config_.get_value("history_depth_sec", 86400)
-        interval_sec = self.config_.get_value("interval_sec", 60)
-
-        pair: TradingPair = self.live_strategy_.trading_pair_
-        subscriptions = [CvttPricesSubscription(
-            exchange_config_name=instrument["exchange_config_name"],
-            instrument_id=instrument["instrument_id"],
-            interval_sec=interval_sec,
-            history_depth_sec=history_depth_sec,
-            callback=partial(
-                self.on_message, instrument_id=instrument["instrument_id"]
-            ),
-        ) for instrument in pair.instruments_]
-
-        for subscription in subscriptions:
-            Log.info(f"{self.fname()} Subscribing to {subscription}")
-            await self.pricer_client_.subscribe(subscription)
-
-    async def on_message(
-        self,
-        message_type: MessageTypeT,
-        subscr_id: SubscriptionIdT,
-        message: Dict,
-        instrument_id: str,
-    ) -> None:
-        Log.info(f"{self.fname()}: {message_type=} {subscr_id=} {instrument_id}")
-        aggr: JsonDictT
-        if message_type == "md_aggregate":
-            aggr = message.get("md_aggregate", {})
-            await self.live_strategy_.on_mkt_data_update(aggr)
-        elif message_type == "historical_md_aggregate":
-            aggr = message.get("historical_data", {})
-            await self.live_strategy_.on_mkt_data_hist_snapshot(aggr)
-        else:
-            Log.info(f"Unknown message type: {message_type}")
-
-    async def run(self) -> None:
-        if not await CvttPricerWebSockClient.check_connection(self.pricer_client_.ws_url_):
-            Log.error(f"Unable to connect to {self.pricer_client_.ws_url_}")
-            raise Exception(f"Unable to connect to {self.pricer_client_.ws_url_}")
-        await self._subscribe()
-
-        await self.pricer_client_.run()

lib/pt_strategy/live/ti_sender.py

@@ -1,86 +0,0 @@
-import time
-from enum import Enum
-from typing import Tuple
-
-# import aiohttp
-from cvttpy_tools.tools.app import App
-from cvttpy_tools.tools.base import NamedObject
-from cvttpy_tools.tools.config import Config
-from cvttpy_tools.tools.logger import Log
-from cvttpy_tools.tools.timer import Timer
-from cvttpy_tools.tools.timeutils import NanoPerSec
-from cvttpy_tools.tools.web.rest_client import REST_RequestProcessor
-
-
-class TradingInstructionsSender(NamedObject):
-
-    class TradingInstType(str, Enum):
-        TARGET_POSITION = "TARGET_POSITION"
-        DIRECT_ORDER = "DIRECT_ORDER"
-        MARKET_MAKING = "MARKET_MAKING"
-        NONE = "NONE"
-
-    config_: Config
-    ti_method_: str
-    ti_url_: str
-    health_check_method_: str
-    health_check_url_: str
-
-    def __init__(self, config: Config):
-        self.config_ = config
-        base_url = config.get_value("url", "ws://localhost:12346/ws")
-        
-        self.book_id_ = config.get_value("book_id", "")
-        assert self.book_id_, "book_id is required"
-        
-        self.strategy_id_ = config.get_value("strategy_id", "")
-        assert self.strategy_id_, "strategy_id is required"
-        
-        endpoint_uri = config.get_value("ti_endpoint/url", "/trading_instructions")
-        endpoint_method = config.get_value("ti_endpoint/method", "POST")
-
-        health_check_uri = config.get_value("health_check_endpoint/url", "/ping")
-        health_check_method = config.get_value("health_check_endpoint/method", "GET")
-
-
-        
-        self.ti_method_ = endpoint_method
-        self.ti_url_ = f"{base_url}{endpoint_uri}"
-        
-        self.health_check_method_ = health_check_method
-        self.health_check_url_ = f"{base_url}{health_check_uri}"
-        
-        App.instance().add_call(App.Stage.Start, self._set_health_check_timer(), can_run_now=True)
- 
-    async def _set_health_check_timer(self) -> None:
-        # TODO: configurable interval
-        self.health_check_timer_ = Timer(is_periodic=True, period_interval=15, start_in_sec=0, func=self._health_check)
-        Log.info(f"{self.fname()} Health check timer set to 15 seconds")
-            
-    async def _health_check(self) -> None:
-        rqst = REST_RequestProcessor(method=self.health_check_method_, url=self.health_check_url_)
-        async with rqst as (status, msg, headers):
-            if status != 200:
-                Log.error(f"{self.fname()} CVTT Service is not responding")
-
-    async def send_tgt_positions(self, strength: float, base_asset: str, quote_asset: str) -> Tuple[int, str]:
-        instr = {
-            "type": self.TradingInstType.TARGET_POSITION.value,
-            "book_id": self.book_id_,
-            "strategy_id": self.strategy_id_,
-            "issued_ts_ns": int(time.time() * NanoPerSec),
-            "data": {
-                "strength": strength,
-                "base_asset": base_asset,
-                "quote_asset": quote_asset,
-                "user_data": {},
-            },
-        }
-        
-        rqst = REST_RequestProcessor(method=self.ti_method_, url=self.ti_url_, params=instr)
-        async with rqst as (status, msg, headers):
-            if status != 200:
-                raise ConnectionError(f"Failed to send trading instructions: {msg}")
-            return (status, msg)
-
-

lib/pt_strategy/pt_market_data.py

@@ -1,229 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-import pandas as pd
-from cvttpy_tools.settings.cvtt_types import JsonDictT
-from tools.data_loader import load_market_data
-
-
-class PtMarketData():
-    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()
-        self.market_data_df_ = pd.DataFrame()
-
-
-class ResearchMarketData(PtMarketData):
-    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.origin_mkt_data_df_ = self.origin_mkt_data_df_.sort_values(by="tstamp")
-        self.origin_mkt_data_df_ = self.origin_mkt_data_df_.dropna().reset_index(drop=True)
-        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_}",
-        ]
-
-class RealTimeMarketData(PtMarketData):
-      
-    def __init__(self, config: Dict[str, Any], *args: Any, **kwargs: Any):
-        super().__init__(config, *args, **kwargs)
-        
-    async def on_mkt_data_hist_snapshot(self, snapshot: JsonDictT) -> None:
-        # URGENT
-        # create origin_mkt_data_df_ from snapshot
-        # verify that the data for both instruments are present
-        
-        # transform it to market_data_df_ tstamp, close_symbolA, close_symbolB
-        '''
-        # from cvttpy/exchanges/binance/spot/mkt_data.py
-        values = {
-            "time_ns": time_ns,
-            "tstamp": format_nanos_utc(time_ns),
-            "exchange_id": exch_inst.exchange_id_,
-            "instrument_id": exch_inst.instrument_id(),
-            "interval_ns": interval_sec * 1_000_000_000,
-            "open": float(kline[1]),
-            "high": float(kline[2]),
-            "low": float(kline[3]),
-            "close": float(kline[4]),
-            "volume": float(kline[5]),
-            "num_trades": kline[8],
-            "vwap": float(kline[7]) / float(kline[5]) if float(kline[5]) > 0 else 0.0  # Calculate VWAP
-        }
-        '''
-
-
-        pass
-    
-    async def on_mkt_data_update(self, update: JsonDictT) -> Optional[pd.DataFrame]:
-        # URGENT
-        # make sure update has both instruments
-        # create DataFrame tmp1 from update
-        # transform tmp1 into temp. datframe  tmp2
-        # add tmp1 to origin_mkt_data_df_
-        # add tmp2 to market_data_df_
-        # return market_data_df_
-        '''
-        class MdTradesAggregate(NamedObject):
-        def to_dict(self) -> Dict[str, Any]:
-            return {
-                "time_ns": self.time_ns_,
-                "tstamp": format_nanos_utc(self.time_ns_),
-                "exchange_id": self.exch_inst_.exchange_id_,
-                "instrument_id": self.exch_inst_.instrument_id(),
-                "interval_ns": self.interval_ns_,
-                "open": self.exch_inst_.get_price(self.open_),
-                "high": self.exch_inst_.get_price(self.high_),
-                "low": self.exch_inst_.get_price(self.low_),
-                "close": self.exch_inst_.get_price(self.close_),
-                "volume": self.exch_inst_.get_quantity(self.volume_),
-                "vwap": self.exch_inst_.get_price(self.vwap_),
-                "num_trades": self.exch_inst_.get_quantity(self.num_trades_),
-            }
-        '''
-        
-        return pd.DataFrame()

lib/tools/instruments.py

@@ -1,21 +0,0 @@
-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
-

notebooks/.gitkeep

@@ -0,0 +1 @@
+

notebooks/spbt_day.ipynb

@@ -0,0 +1,357 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "single-day-title",
+   "metadata": {},
+   "source": [
+    "# Single-Day Backtest Result Analysis\n",
+    "\n",
+    "This notebook analyzes the result of one single-day backtest stored in a SQLite database. Development is staged; Step 1 only selects the database file that later sections will read.\n",
+    "\n",
+    "Input assumptions for Step 1:\n",
+    "\n",
+    "- The default data directory is `data/` at the repository root.\n",
+    "- SQLite result files usually use `.db`, `.sqlite`, or `.sqlite3` extensions.\n",
+    "- The directory can be changed interactively if the result file lives elsewhere."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "imports-and-paths",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import importlib\n",
+    "import sys\n",
+    "\n",
+    "from IPython.display import display\n",
+    "import ipywidgets as widgets\n",
+    "import pandas as pd\n",
+    "\n",
+    "START_DIR = Path.cwd().resolve()\n",
+    "for candidate in (START_DIR, *START_DIR.parents):\n",
+    "    if (candidate / \"scripts\" / \"spbt_day.py\").exists():\n",
+    "        if str(candidate) not in sys.path:\n",
+    "            sys.path.insert(0, str(candidate))\n",
+    "        break\n",
+    "\n",
+    "import scripts.spbt_day as spbt_day\n",
+    "\n",
+    "spbt_day = importlib.reload(spbt_day)\n",
+    "\n",
+    "add_total_pnl = spbt_day.add_total_pnl\n",
+    "calculate_pair_theo_executions = spbt_day.calculate_pair_theo_executions\n",
+    "calculate_ranked_pairs_theo_ret = spbt_day.calculate_ranked_pairs_theo_ret\n",
+    "create_database_file_selector = spbt_day.create_database_file_selector\n",
+    "create_pair_name_dropdown = spbt_day.create_pair_name_dropdown\n",
+    "create_pair_trades_market_plot = spbt_day.create_pair_trades_market_plot\n",
+    "create_total_pnl_histogram = spbt_day.create_total_pnl_histogram\n",
+    "find_repo_root = spbt_day.find_repo_root\n",
+    "format_pair_name_for_display = spbt_day.format_pair_name_for_display\n",
+    "format_pair_names_for_display = spbt_day.format_pair_names_for_display\n",
+    "infer_trading_day_start_ns = spbt_day.infer_trading_day_start_ns\n",
+    "load_selector_pair_rankings = spbt_day.load_selector_pair_rankings\n",
+    "load_pair_market_data = spbt_day.load_pair_market_data\n",
+    "load_trading_instructions = spbt_day.load_trading_instructions\n",
+    "show_interactive_dataframe = spbt_day.show_interactive_dataframe\n",
+    "\n",
+    "REPO_ROOT = find_repo_root()\n",
+    "DEFAULT_DATA_DIR = REPO_ROOT / \"data\"\n",
+    "\n",
+    "REPO_ROOT, DEFAULT_DATA_DIR"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "database-file-selector",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "db_selector = create_database_file_selector(\n",
+    "    default_data_dir=DEFAULT_DATA_DIR,\n",
+    "    repo_root=REPO_ROOT,\n",
+    ")\n",
+    "\n",
+    "display(db_selector.widget)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "selected-database-helpers",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "selected_database_path = db_selector.selected_database_path\n",
+    "connect_selected_database = db_selector.connect_selected_database\n",
+    "\n",
+    "# Later notebook sections can call selected_database_path() or connect_selected_database()."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "selector-pair-rankings-context",
+   "metadata": {},
+   "source": [
+    "## Selector Pair Rankings\n",
+    "\n",
+    "Load `selector_pairs.pair_name` and `selector_pairs.mr_score` from the selected SQLite database. The JSON field `mr_score.final` is parsed as a numeric score and ranked descending with dense ranks, so tied scores share the same rank and the next distinct score gets the next rank.\n",
+    "\n",
+    "Rows with missing, malformed, non-numeric, or non-finite `mr_score.final` values are preserved, sorted after ranked rows, and marked in `mr_score_parse_status`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "load-selector-pair-rankings",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "conn = connect_selected_database()\n",
+    "try:\n",
+    "    selector_pair_rankings = load_selector_pair_rankings(conn)\n",
+    "finally:\n",
+    "    conn.close()\n",
+    "\n",
+    "selector_pair_rankings_display = format_pair_names_for_display(\n",
+    "    selector_pair_rankings[[\"pair_rank\", \"pair_name\", \"mr_score_final\"]]\n",
+    ")\n",
+    "with pd.option_context(\"display.max_rows\", None):\n",
+    "    display(selector_pair_rankings_display)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "theoretical-return-context",
+   "metadata": {},
+   "source": [
+    "## Theoretical Return by Pair\n",
+    "\n",
+    "Load `trading_instructions` and calculate theoretical return for each ranked pair. Each pair starts from a fixed `$10,000` theoretical USD base. `TARGET` trades from the current theoretical position to the new target position, where target size is `10000 * strength / reference_price`; `CLOSE` liquidates the open position at the close row's `reference_price`; `HOLD` is ignored.\n",
+    "\n",
+    "`MIN_TARGET_STRENGTH_CHANGE_PCTG` can be raised above `0.0` to skip `TARGET` updates whose absolute percentage strength change is smaller than the threshold since the position was acquired. `num_trades` counts asset-level theoretical trades caused by effective `TARGET` and `CLOSE` rows. `realized_pnl` and `unrealized_pnl` are percentage returns relative to `$10,000`. The displayed dataframe is sorted by total return (`realized_pnl + unrealized_pnl`) ascending."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "target-change-threshold-input",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "min_target_change_input = widgets.FloatText(\n",
+    "    value=0.0,\n",
+    "    description=\"Mininal TARGET change (%)\",\n",
+    "    step=1.0,\n",
+    "    layout=widgets.Layout(width=\"420px\"),\n",
+    "    style={\"description_width\": \"190px\"},\n",
+    ")\n",
+    "display(min_target_change_input)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "load-trading-instructions",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "conn = connect_selected_database()\n",
+    "try:\n",
+    "    trading_instructions = load_trading_instructions(conn)\n",
+    "finally:\n",
+    "    conn.close()\n",
+    "\n",
+    "print(f\"Loaded {len(trading_instructions):,} trading instruction rows.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "calculate-pair-theoretical-returns",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MIN_TARGET_STRENGTH_CHANGE_PCTG = float(min_target_change_input.value)\n",
+    "\n",
+    "pair_theo_ret = add_total_pnl(\n",
+    "    calculate_ranked_pairs_theo_ret(\n",
+    "        selector_pair_rankings,\n",
+    "        trading_instructions,\n",
+    "        min_pctg_change=MIN_TARGET_STRENGTH_CHANGE_PCTG,\n",
+    "    )\n",
+    ").sort_values(\n",
+    "    [\"total_pnl\", \"pair_name\"],\n",
+    "    ascending=[True, True],\n",
+    "    kind=\"mergesort\",\n",
+    ").drop(columns=\"total_pnl\").reset_index(drop=True)\n",
+    "\n",
+    "pair_theo_ret_display = format_pair_names_for_display(pair_theo_ret)\n",
+    "\n",
+    "show_interactive_dataframe(\n",
+    "    pair_theo_ret_display,\n",
+    "    table_id=\"pair-theo-ret-grid\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "theoretical-return-histogram-context",
+   "metadata": {},
+   "source": [
+    "## Total Theoretical Return Distribution\n",
+    "\n",
+    "Plot the distribution of total theoretical return, calculated as `realized_pnl + unrealized_pnl`. Plotly chooses histogram bins automatically."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "plot-total-theoretical-return-histogram",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "total_pnl_histogram = create_total_pnl_histogram(pair_theo_ret)\n",
+    "\n",
+    "total_pnl_histogram"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "individual-pair-analysis-context",
+   "metadata": {},
+   "source": [
+    "## Individual Pair Analysis\n",
+    "\n",
+    "Choose one pair for detailed follow-up analysis. Pair names are sorted alphabetically."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "choose-individual-pair",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pair_name_dropdown = create_pair_name_dropdown(selector_pair_rankings)\n",
+    "display(pair_name_dropdown)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "selected-individual-pair",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "selected_pair_name = pair_name_dropdown.value\n",
+    "format_pair_name_for_display(selected_pair_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "selected-pair-theo-executions-context",
+   "metadata": {},
+   "source": [
+    "### Selected Pair Theoretical Executions\n",
+    "\n",
+    "Create the theoretical asset-level executions used by the PnL calculation for the selected pair. `TARGET` rows trade the position difference from the current theoretical position to the new target position, where target size is `10000 * strength / reference_price`; `CLOSE` rows flatten the current theoretical position. Positive size is `BUY`; negative size is `SELL`; USD value is signed as the opposite cash movement."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "selected-pair-theo-executions",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "selected_pair_theo_executions = calculate_pair_theo_executions(\n",
+    "    selected_pair_name,\n",
+    "    trading_instructions,\n",
+    "    min_pctg_change=MIN_TARGET_STRENGTH_CHANGE_PCTG,\n",
+    ")\n",
+    "\n",
+    "selected_pair_theo_execution_columns = [\n",
+    "    \"time\",\n",
+    "    \"asset\",\n",
+    "    \"action\",\n",
+    "    \"side\",\n",
+    "    \"strength\",\n",
+    "    \"size\",\n",
+    "    \"price\",\n",
+    "    \"usd_value\",\n",
+    "]\n",
+    "selected_pair_theo_executions_display = selected_pair_theo_executions.reindex(\n",
+    "    columns=selected_pair_theo_execution_columns\n",
+    ")\n",
+    "show_interactive_dataframe(\n",
+    "    selected_pair_theo_executions_display,\n",
+    "    table_id=\"selected-pair-theo-executions-grid\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "selected-pair-market-trades-context",
+   "metadata": {},
+   "source": [
+    "### Selected Pair Trades on Market Data\n",
+    "\n",
+    "Load full available 1-minute market data for the selected pair's instruments from `ohlcv_1min`, starting at midnight UTC of the trading day inferred from `trading_instructions`. Close prices are shown as relative prices from each instrument's close at that midnight. Theoretical executions are overlaid at their execution `reference_price`, normalized by the same midnight close. Execution markers use execution timestamps directly and do not require a matching OHLCV row."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "selected-pair-market-trades-plot",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trading_day_start_ns = infer_trading_day_start_ns(trading_instructions)\n",
+    "\n",
+    "conn = connect_selected_database()\n",
+    "try:\n",
+    "    selected_pair_market_data = load_pair_market_data(\n",
+    "        conn,\n",
+    "        selected_pair_name,\n",
+    "        trading_day_start_ns=trading_day_start_ns,\n",
+    "    )\n",
+    "finally:\n",
+    "    conn.close()\n",
+    "\n",
+    "selected_pair_market_trades_plot = create_pair_trades_market_plot(\n",
+    "    selected_pair_name,\n",
+    "    selected_pair_market_data,\n",
+    "    selected_pair_theo_executions,\n",
+    ")\n",
+    "\n",
+    "selected_pair_market_trades_plot"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "python3.12-venv (3.12.13.final.0)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

pyproject.toml

@@ -1,66 +0,0 @@
-[build-system]
-requires = ["setuptools>=45", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "pairs-trading"
-version = "0.1.0"
-description = "Pairs Trading Backtesting Framework"
-requires-python = ">=3.8"
-
-[tool.black]
-line-length = 88
-target-version = ['py38']
-include = '\.pyi?$'
-extend-exclude = '''
-/(
-  # directories
-  \.eggs
-  | \.git
-  | \.hg
-  | \.mypy_cache
-  | \.tox
-  | \.venv
-  | build
-  | dist
-)/
-'''
-
-[tool.flake8]
-max-line-length = 88
-extend-ignore = ["E203", "W503"]
-exclude = [
-    ".git",
-    "__pycache__",
-    "build",
-    "dist",
-    ".venv",
-    ".mypy_cache",
-    ".tox"
-]
-
-[tool.mypy]
-python_version = "3.8"
-warn_return_any = true
-warn_unused_configs = true
-disallow_untyped_defs = true
-disallow_incomplete_defs = true
-check_untyped_defs = true
-disallow_untyped_decorators = true
-no_implicit_optional = true
-warn_redundant_casts = true
-warn_unused_ignores = true
-warn_no_return = true
-warn_unreachable = true
-strict_equality = true
-
-[[tool.mypy.overrides]]
-module = [
-    "numpy.*",
-    "pandas.*",
-    "matplotlib.*",
-    "seaborn.*",
-    "scipy.*",
-    "sklearn.*"
-]
-ignore_missing_imports = true 

pyrightconfig.json

@@ -1,25 +0,0 @@
-{
-    "include": [
-        "lib"
-    ],
-    "exclude": [
-        "**/node_modules",
-        "**/__pycache__",
-        "**/.*",
-        "results",
-        "data"
-    ],
-    "ignore": [],
-    "defineConstant": {},
-    "typeCheckingMode": "basic",
-    "useLibraryCodeForTypes": true,
-    "autoImportCompletions": true,
-    "autoSearchPaths": true,
-    "extraPaths": [
-        "lib",
-        ".."
-    ],
-    "stubPath": "./typings",
-    "venvPath": ".",
-    "venv": "python3.12-venv"
-}

requirements.txt

@@ -1,200 +1,12 @@
-aiohttp>=3.8.4
+# Interactive analysis
-aiosignal>=1.3.1
+ipykernel>=6.29,<7
-async-timeout>=4.0.2
+ipywidgets>=8.1,<9
-attrs>=21.2.0
+itables>=2.2,<3
-beautifulsoup4>=4.10.0
+jupyter>=1.1,<2
-black>=23.3.0
+nbformat>=5.10,<6
-flake8>=6.0.0
+pandas>=2.2,<3
-certifi>=2020.6.20
+plotly>=5.24,<7
-chardet>=4.0.0
+
-charset-normalizer>=3.1.0
+# Verification
-click>=8.0.3
+nbmake>=1.5,<2
-colorama>=0.4.4
+pytest>=8,<9
-configobj>=5.0.6
-cryptography>=3.4.8
-distro>=1.7.0
-docker>=5.0.3
-dockerpty>=0.4.1
-docopt>=0.6.2
-eyeD3>=0.8.10
-filelock>=3.6.0
-frozenlist>=1.3.3
-grpcio>=1.30.2
-hjson>=3.0.2
-html5lib>=1.1
-httplib2>=0.20.2
-idna>=3.3
-ipython>=8.18.1
-ipywidgets>=8.1.1
-ifaddr>=0.1.7
-IMDbPY>=2021.4.18
-ipykernel>=6.29.5
-jeepney>=0.7.1
-jsonschema>=3.2.0
-jupyter>=1.0.0
-keyring>=23.5.0
-launchpadlib>=1.10.16
-lazr.restfulclient>=0.14.4
-lazr.uri>=1.0.6
-lxml>=4.8.0
-Mako>=1.1.3
-Markdown>=3.3.6
-MarkupSafe>=2.0.1
-matplotlib>=3.10.3
-more-itertools>=8.10.0
-multidict>=6.0.4
-mypy>=0.942
-mypy-extensions>=0.4.3
-nbformat>=5.10.2
-netaddr>=0.8.0
-######### netifaces>=0.11.0
-numpy>=1.26.4,<2.3.0
-oauthlib>=3.2.0
-packaging>=23.1
-pandas>=2.2.3
-pathspec>=0.11.1
-pexpect>=4.8.0
-Pillow>=9.0.1
-platformdirs>=3.2.0
-plotly>=5.19.0
-protobuf>=3.12.4
-psutil>=5.9.0
-ptyprocess>=0.7.0
-pycurl>=7.44.1
-pyelftools>=0.27
-Pygments>=2.11.2
-pyparsing>=2.4.7
-pyrsistent>=0.18.1
-python-debian>=0.1.43 #+ubuntu1.1
-python-dotenv>=0.19.2
-python-magic>=0.4.24
-python-xlib>=0.29
-pyxdg>=0.27
-PyYAML>=6.0
-reportlab>=3.6.8
-requests>=2.25.1
-requests-file>=1.5.1
-scipy<1.13.0
-seaborn>=0.13.2
-SecretStorage>=3.3.1
-setproctitle>=1.2.2
-simpleeval>=1.0.3
-six>=1.16.0
-soupsieve>=2.3.1
-ssh-import-id>=5.11
-statsmodels>=0.14.4
-texttable>=1.6.4
-tldextract>=3.1.2
-tomli>=1.2.2
-######## typed-ast>=1.4.3
-types-aiofiles>=0.1
-types-annoy>=1.17
-types-appdirs>=1.4
-types-atomicwrites>=1.4
-types-aws-xray-sdk>=2.8
-types-babel>=2.9
-types-backports-abc>=0.5
-types-backports.ssl-match-hostname>=3.7
-types-beautifulsoup4>=4.10
-types-bleach>=4.1
-types-boto>=2.49
-types-braintree>=4.11
-types-cachetools>=4.2
-types-caldav>=0.8
-types-certifi>=2020.4
-types-characteristic>=14.3
-types-chardet>=4.0
-types-click>=7.1
-types-click-spinner>=0.1
-types-colorama>=0.4
-types-commonmark>=0.9
-types-contextvars>=0.1
-types-croniter>=1.0
-types-cryptography>=3.3
-types-dataclasses>=0.1
-types-dateparser>=1.0
-types-DateTimeRange>=0.1
-types-decorator>=0.1
-types-Deprecated>=1.2
-types-docopt>=0.6
-types-docutils>=0.17
-types-editdistance>=0.5
-types-emoji>=1.2
-types-entrypoints>=0.3
-types-enum34>=1.1
-types-filelock>=3.2
-types-first>=2.0
-types-Flask>=1.1
-types-freezegun>=1.1
-types-frozendict>=0.1
-types-futures>=3.3
-types-html5lib>=1.1
-types-httplib2>=0.19
-types-humanfriendly>=9.2
-types-ipaddress>=1.0
-types-itsdangerous>=1.1
-types-JACK-Client>=0.1
-types-Jinja2>=2.11
-types-jmespath>=0.10
-types-jsonschema>=3.2
-types-Markdown>=3.3
-types-MarkupSafe>=1.1
-types-mock>=4.0
-types-mypy-extensions>=0.4
-types-mysqlclient>=2.0
-types-oauthlib>=3.1
-types-orjson>=3.6
-types-paramiko>=2.7
-types-Pillow>=8.3
-types-polib>=1.1
-types-prettytable>=2.1
-types-protobuf>=3.17
-types-psutil>=5.8
-types-psycopg2>=2.9
-types-pyaudio>=0.2
-types-pycurl>=0.1
-types-pyfarmhash>=0.2
-types-Pygments>=2.9
-types-PyMySQL>=1.0
-types-pyOpenSSL>=20.0
-types-pyRFC3339>=0.1
-types-pysftp>=0.2
-types-pytest-lazy-fixture>=0.6
-types-python-dateutil>=2.8
-types-python-gflags>=3.1
-types-python-nmap>=0.6
-types-python-slugify>=5.0
-types-pytz>=2021.1
-types-pyvmomi>=7.0
-types-PyYAML>=5.4
-types-redis>=3.5
-types-requests>=2.25
-types-retry>=0.9
-types-selenium>=3.141
-types-Send2Trash>=1.8
-types-setuptools>=57.4
-types-simplejson>=3.17
-types-singledispatch>=3.7
-types-six>=1.16
-types-slumber>=0.7
-types-stripe>=2.59
-types-tabulate>=0.8
-types-termcolor>=1.1
-types-toml>=0.10
-types-toposort>=1.6
-types-ttkthemes>=3.2
-types-typed-ast>=1.4
-types-tzlocal>=0.1
-types-ujson>=0.1
-types-vobject>=0.9
-types-waitress>=0.1
-types-Werkzeug>=1.0
-types-xxhash>=2.0
-typing-extensions>=3.10.0.2
-Unidecode>=1.3.3
-urllib3>=1.26.5
-wadllib>=1.3.6
-webencodings>=0.5.1
-websocket-client>=1.2.3
-yarl>=1.9.1
-zipp>=1.0.0

research/backtest.py

@@ -1,106 +0,0 @@
-from __future__ import annotations
-
-import os
-from typing import Any, Dict
-
-from pt_strategy.results import (
-    PairResearchResult,
-    create_result_database,
-    store_config_in_database,
-)
-from pt_strategy.research_strategy import PtResearchStrategy
-from tools.filetools import resolve_datafiles
-from tools.instruments import get_instruments
-
-
-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(),
-        )
-
-
-    results.analyze_pair_performance()
-
-
-    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()

research/tools/research_tools.py

@@ -1,94 +0,0 @@
-import glob
-import os
-from typing import Dict, List, Optional
-
-import pandas as pd
-from pt_trading.fit_method import PairsTradingFitMethod
-
-
-def resolve_datafiles(config: Dict, cli_datafiles: Optional[str] = None) -> List[str]:
-    """
-    Resolve the list of data files to process.
-    CLI datafiles take priority over config datafiles.
-    Supports wildcards in config but not in CLI.
-    """
-    if cli_datafiles:
-        # CLI override - comma-separated list, no wildcards
-        datafiles = [f.strip() for f in cli_datafiles.split(",")]
-        # Make paths absolute relative to data directory
-        data_dir = config.get("data_directory", "./data")
-        resolved_files = []
-        for df in datafiles:
-            if not os.path.isabs(df):
-                df = os.path.join(data_dir, df)
-            resolved_files.append(df)
-        return resolved_files
-
-    # Use config datafiles with wildcard support
-    config_datafiles = config.get("datafiles", [])
-    data_dir = config.get("data_directory", "./data")
-    resolved_files = []
-
-    for pattern in config_datafiles:
-        if "*" in pattern or "?" in pattern:
-            # Handle wildcards
-            if not os.path.isabs(pattern):
-                pattern = os.path.join(data_dir, pattern)
-            matched_files = glob.glob(pattern)
-            resolved_files.extend(matched_files)
-        else:
-            # Handle explicit file path
-            if not os.path.isabs(pattern):
-                pattern = os.path.join(data_dir, pattern)
-            resolved_files.append(pattern)
-
-    return sorted(list(set(resolved_files)))  # Remove duplicates and sort
-
-
-def create_pairs(
-    datafiles: List[str],
-    fit_method: PairsTradingFitMethod,
-    config: Dict,
-    instruments: List[Dict[str, str]],
-) -> List:
-    from pt_trading.trading_pair import TradingPair
-    from tools.data_loader import load_market_data
-
-    all_indexes = range(len(instruments))
-    unique_index_pairs = [(i, j) for i in all_indexes for j in all_indexes if i < j]
-    pairs = []
-
-    # Update config to use the specified instruments
-    config_copy = config.copy()
-    config_copy["instruments"] = instruments
-
-    market_data_df = pd.DataFrame()
-    extra_minutes = 0
-    if "execution_price" in config_copy:
-        extra_minutes = config_copy["execution_price"]["shift"]
-
-    for datafile in datafiles:
-        md_df = load_market_data(
-            datafile=datafile,
-            instruments=instruments,
-            db_table_name=config_copy["market_data_loading"][instruments[0]["instrument_type"]]["db_table_name"],
-            trading_hours=config_copy["trading_hours"],
-            extra_minutes=extra_minutes,
-        )
-        market_data_df = pd.concat([market_data_df, md_df])
-
-    if len(set(market_data_df["symbol"])) != 2: # both symbols must be present for a pair
-        print(f"WARNING: insufficient data in files: {datafiles}")
-        return []
-
-    for a_index, b_index in unique_index_pairs:
-        symbol_a=instruments[a_index]["symbol"]
-        symbol_b=instruments[b_index]["symbol"]
-        pair = fit_method.create_trading_pair(
-            config=config_copy,
-            market_data=market_data_df,
-            symbol_a=symbol_a,
-            symbol_b=symbol_b,
-        )
-        pairs.append(pair)
-    return pairs

results/.gitkeep

@@ -0,0 +1 @@
+

scripts/.gitkeep

@@ -0,0 +1 @@
+

tests/viz_test.py

@@ -1,111 +0,0 @@
-from __future__ import annotations
-
-import os
-from typing import Any, Dict
-
-from pt_strategy.results import (PairResearchResult, create_result_database,
-                                 store_config_in_database)
-from pt_strategy.research_strategy import PtResearchStrategy
-from tools.filetools import resolve_datafiles
-from tools.instruments import get_instruments
-from tools.viz.viz_trades import visualize_trades
-
-
-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=False,
-        default="NONE",
-        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(),
-        )
-
-
-    results.analyze_pair_performance()
-    
-    
-    visualize_trades(pt_strategy, results, day)
-
-
-    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()