| # BankNifty Strategy Engine — README | |
| A **resumable**, **LLM-driven** intraday engine that digests sentiment, expert transcripts, technicals (RSI/MACD), and news to produce trade plans for **BankNifty** (and Nifty for context). The engine simulates executions on **1-minute** data, evaluates P&L, and keeps airtight checkpoints so you can **resume exactly where you left off** after interruptions. | |
| --- | |
| ## Table of contents | |
| - [Features](#features) | |
| - [Project structure](#project-structure) | |
| - [Data inputs & expected columns](#data-inputs--expected-columns) | |
| - [Installation](#installation) | |
| - [Configuration (.env + config classes)](#configuration-env--config-classes) | |
| - [Running](#running) | |
| - [Resumable checkpoints](#resumable-checkpoints) | |
| - [How the engine works (timeline)](#how-the-engine-works-timeline) | |
| - [Trade simulation rules](#trade-simulation-rules) | |
| - [LLM JSON schemas](#llm-json-schemas) | |
| - [Outputs](#outputs) | |
| --- | |
| ## Features | |
| - 🧠 **LLM-assisted** trade plans using structured JSON outputs (strict schema). | |
| - 📰 **News-aware** decisions (hourly, last 15 mins at close). | |
| - 📈 **Technicals**: RSI + MACD on hourly/daily series. | |
| - 🧪 **1-minute backtest execution** with deterministic tiebreak rules. | |
| - 🔁 **Resumable** runs via checkpoint (safe to kill & rerun). | |
| - ✅ **Flip/No-trade exit enforcement**: if plan flips side or says “No trade” while holding, engine exits at market price. | |
| - 🧠 **Memory** string summarizing the last completed trade gets fed back into prompts. | |
| - 📦 **Excel & Parquet** logs for analysis. | |
| --- | |
| ## Project structure | |
| ``` | |
| banknifty_strategy/ | |
| ├─ app/ | |
| │ ├─ __init__.py | |
| │ ├─ engine.py # Core loop (09:15 → … → 15:30) | |
| │ ├─ models.py # Pydantic v2 models | |
| │ ├─ prompts.py # Prompt templates: morning / intrahour / closing | |
| │ ├─ simulator.py # simulate_trade_from_signal, slice_intraday | |
| │ ├─ dataio.py # load_data() – reads/normalizes data frames | |
| │ ├─ checkpoint.py # CheckpointManager – resume & append parquet logs | |
| │ ├─ logging_setup.py # Rotating file/logger | |
| │ ├─ config.py # AppConfig, Paths, LLMConfig | |
| │ ├─ llm.py # OpenAI client wrapper; strict JSON schema handling | |
| │ ├─ news.py # summaries_between() helpers | |
| │ ├─ utils.py # hour_passed(), hourly_ohlc_dict(), helpers | |
| │ └─ writer.py # to_excel_safely() | |
| ├─ scripts/ | |
| │ └─ run_backtest.py # CLI entrypoint | |
| ├─ requirements.txt | |
| └─ README.md | |
| ``` | |
| > **Note**: Keep `app/` a proper package (it must include `__init__.py`). Always run from the project root so imports like `from app.engine import Engine` work. | |
| --- | |
| ## Data inputs & expected columns | |
| Your **loader** (`app/dataio.py`) should read and normalize sources. The engine expects these **canonical** frames and columns: | |
| ### 1. BankNifty hourly (`df_bn_hourly`) | |
| - Columns: `datetime`, `open`, `high`, `low`, `close`, `RSI`, `MACD_Line`, `Signal_Line` | |
| - Granularity: **hourly** (09:15, 10:15, …, 15:15, 15:30) | |
| - Used for: 09:15 previous indicators, hourly OHLC dicts, close price lookup. | |
| ### 2. BankNifty 1-minute (`df_bn_1m`) | |
| - Columns: `datetime`, `open`, `high`, `low`, `close` | |
| - Granularity: **1 min** | |
| - Used by: **simulate_trade_from_signal** execution windows. | |
| ### 3. Nifty daily or daily-like context (`df_nifty_daily`) | |
| - Columns: `datetime`, `open`, `high`, `low`, `close`, `RSI`, `MACD_Line`, `Signal_Line` | |
| - Used for: contextual morning prompt. | |
| ### 4. Sentiment predictions (`df_sentiment`) | |
| - Columns: `predicted_for` (datetime), `proposed_sentiment`, `reasoning` | |
| ### 5. Expert transcript (`df_transcript`) | |
| - Columns: `prediction_for` (datetime), `Transcript` | |
| - (If your raw file has `Prediction_for_date`, normalize to `prediction_for`.) | |
| ### 6. News with summaries (`df_news`) | |
| - Columns: `datetime_ist` (datetime), `Article_summary` (string) | |
| > Ensure all datetime columns are timezone-normalized (naive or same tz) and parsed. | |
| --- | |
| ## Installation | |
| **Python 3.9+** recommended. | |
| ```bash | |
| pip install -r requirements.txt | |
| ``` | |
| --- | |
| ## Configuration (.env + config classes) | |
| Create a **.env** in project root: | |
| ```env | |
| OPENAI_API_KEY=EMPTY | |
| OPENAI_BASE_URL=http://localhost:8000/v1 | |
| OPENAI_MODEL=Qwen/Qwen3-4B | |
| ``` | |
| Edit temperature and top_p values from: | |
| - `app/config.py` | |
| --- | |
| ## Running | |
| Use the provided script. **Minimal edits** added `--ckpt-dir` (defaults to `<out-dir>/checkpoint`). | |
| ```bash | |
| # Always run from project root so "app" package is on sys.path | |
| python -m scripts.run_backtest --data-dir ./data --out-dir ./result --start "2023-12-29 15:15" --end "2024-05-01 09:15" | |
| ``` | |
| --- | |
| ## Resumable checkpoints | |
| The engine persists state and logs in **Parquet** inside `--ckpt-dir`: | |
| ``` | |
| <ckpt-dir>/ | |
| ├─ checkpoint.json # last_timestamp_processed, state, plans, memory_str | |
| ├─ trade_log.parquet | |
| ├─ stats_log.parquet | |
| ├─ expert_log.parquet | |
| └─ summary_log.parquet | |
| ``` | |
| You can **kill** the process and **re-run with the same `--ckpt-dir`**. The engine: | |
| - Reads `checkpoint.json` | |
| - Skips timestamps already processed | |
| - Continues from the next tick | |
| Excel mirrors (`*.xlsx`) are written to `--out-dir` for human inspection. | |
| --- | |
| ## How the engine works (timeline) | |
| At each timestamp `ts` in your **hourly** series: | |
| 1. **09:15 — Morning** | |
| - Gathers **Nifty/BankNifty** previous OHLC + indicators. | |
| - Pulls **sentiment** + **expert transcript**. | |
| - Calls LLM (schema **SummaryMorning**) → morning summary. | |
| - Calls LLM (schema **TradePlan**) → first plan of the day (but the actual open/close is derived dynamically from previous state; first day has no memory). | |
| 2. **10:15 — First intrahour** | |
| - **Simulate** 1-minute window from last slice start → 10:15 using current plan. | |
| - Log **state change** only if it changed by value (not identity). | |
| - If **exited** naturally (stop/target), update **memory_str**, **reset state**, move `last_slice_start`. | |
| - Pull last hour **news**, OHLC dict, current indicators. | |
| - Call LLM (**DecisionOutput** → `{summary_banknifty, trade}`). | |
| - **Flip/No-trade exit enforcement**: if holding and LLM flips side or says “No trade” → **force flatten** at market price (hourly close). | |
| - Update logs. | |
| 3. **11:15 → 15:15 — Subsequent intrahours** | |
| - Same as 10:15 loop. | |
| 4. **15:30 — Close** | |
| - **Simulate last 15 minutes (15:15 → 15:30)** on 1-minute data. | |
| - Log state change once; if exited → update memory + reset. | |
| - LLM **close plan** (schema **TradePlan**). | |
| - If holding and plan flips/no-trade → **force flatten** at close. | |
| - Otherwise **carry overnight** (state remains open). | |
| - Save **checkpoint** after each timestamp. | |
| --- | |
| ## Trade simulation rules | |
| `simulate_trade_from_signal(df, trade, dt_col, state, lookback_minutes)`: | |
| - Trade schema (`TradePlan`): | |
| - `status`: `"Trade"` or `"No trade"` | |
| - `type`: `"long" | "short" | "none"` | |
| - `entry_at`, `target`, `stoploss`: numbers (positive; 0 if `No trade`) | |
| - Entry is **limit-style**: if `entry_at` in `[low, high]` of a 1-min bar → entry fills at `entry_at`. | |
| - Exit resolution when **both target & stoploss could be hit in same bar**: use **tiebreaker** (engine uses “stoploss_first”). | |
| - P&L (`pnl_pct`): signed percentage vs entry (`long` positive if `exit > entry`; `short` inverted). | |
| - **Flip/No-trade** handling in engine: | |
| - If **open_position** and LLM plan flips or says **No trade** at the tick → **force flatten** at minutes **close** (market price) and log memory. | |
| --- | |
| ## LLM JSON schemas | |
| All Pydantic models enforce `extra="forbid"` so the model can’t invent fields. | |
| The client (`app/llm.py`) **sanitizes** the schema name and **forces** `additionalProperties: false` at the **root and nested** objects, satisfying strict servers. | |
| ### SummaryMorning (example) | |
| ```python | |
| class SummaryMorning(BaseModel): | |
| major_concern_nifty50: str | |
| trade_reasoning_nifty50: str | |
| trade_strategy_nifty50: str | |
| major_concern_banknifty: str | |
| trade_reasoning_banknifty: str | |
| trade_strategy_banknifty: str | |
| model_config = {"extra": "forbid"} | |
| ``` | |
| ### TradePlan | |
| ```python | |
| class TradePlan(BaseModel): | |
| status: Literal["No trade", "Trade"] | |
| brief_reason: str | |
| type: Literal["long", "short", "none"] | |
| entry_at: float | |
| target: float | |
| stoploss: float | |
| model_config = {"extra": "forbid"} | |
| ``` | |
| ### DecisionOutput | |
| ```python | |
| class SummaryBankNifty(BaseModel): | |
| major_concern: str | |
| sentiment: Literal["bullish", "bearish"] | |
| reasoning: str | |
| trade_strategy: str | |
| news_summary: str | |
| model_config = {"extra": "forbid"} | |
| class DecisionOutput(BaseModel): | |
| summary_banknifty: SummaryBankNifty | |
| trade: TradePlan | |
| model_config = {"extra": "forbid"} | |
| ``` | |
| --- | |
| ## Outputs | |
| **Out dir (`--out-dir`)**: | |
| - `stats_log.xlsx` – time series of state snapshots/closing stats (one row when state changes; final close row). | |
| - `trade_log.xlsx` – model trade plans over time. | |
| - `expert_log.xlsx` – morning summaries (one per day). | |
| - `summary_log.xlsx` – per-hour summaries. | |
| **Checkpoint dir (`--ckpt-dir` or `<out-dir>/checkpoint`)**: | |
| - Parquets for each log, plus `checkpoint.json` (state & last timestamp). | |