nadex-cli 1.0.0__py3-none-any.whl

nadex_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: nadex-cli
+Version: 1.0.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-dotenv
+Requires-Dist: requests
+Requires-Dist: websockets
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+
+# 📈 nadex — Real-Time 5-Minute Binary Options Market Data CLI
+
+`nadex` is a powerful Python CLI tool that fetches **live 5-minute binary options forex data** directly from the Nadex exchange. With a single command, you can access comprehensive market data including all available forex pairs, trading levels (strikes), bid/ask prices, and order book quantities — transforming your terminal into a real-time trading dashboard.
+
+Perfect for traders, developers, and financial analysts who need instant access to Nadex's binary options market structure and live pricing data.
+
+---
+
+## 🚀 Key Features
+
+- ⏱ **Real-time 5-minute binary options data** for all major forex pairs
+- 💵 **Complete strike levels** with bid/ask prices and available quantities
+- 📊 **Full order book visualization** in your terminal
+- 🔐 **Built-in test credentials** (easily replaceable with your own)
+- 🎯 **Clean, parsable CLI output** for both human reading and automation
+- 🐍 **One-command installation** via PyPI (`pip install nadex`)
+- 🌐 **WebSocket streaming** for real-time updates
+- 📈 **Professional-grade market data** from Nadex exchange
+
+---
+
+## 📦 Quick Installation
+
+Install the package globally using pip:
+
+```bash
+pip install nadex
+```
+
+That's it! No additional setup required.
+
+---
+
+## ⚡ Quick Start
+
+After installation, simply run:
+
+```bash
+nadex_dashboard
+```
+
+The CLI will immediately:
+1. Connect to Nadex using built-in test credentials
+2. Subscribe to the live 5-minute binary options feed
+3. Display real-time market data in a clean, organized format
+
+## 🎯 What You Get
+
+### Complete Market Overview
+- **All Active Forex Pairs**: EUR/USD, GBP/USD, USD/JPY, AUD/USD, USD/CAD, EUR/GBP, 
+- **Strike Levels**: Every available trading level for 5-minute binary options
+- **Bid/Ask Prices**: Real-time pricing from the Nadex order book
+- **Contract Quantities**: Available volume at each price level
+
+### Real-Time Updates
+The dashboard refreshes automatically as new market data arrives via WebSocket connection, ensuring you always see the latest:
+- Price movements
+- Quantity changes
+- New strike levels
+- Market status updates
+
+---
+
+## 🔑 Authentication & Credentials
+
+### Default Test Mode
+The package comes with **built-in test credentials** that connect to Nadex's demo environment. This means:
+- ✅ No real money involved
+- ✅ Full access to live market data structure
+- ✅ Perfect for learning and development
+- ✅ No registration required
+
+### Using Your Own Credentials
+
+If you have a Nadex account and want to use your own credentials:
+
+#### Method 1: Environment Variables
+```bash
+export NADEX_USERNAME=your-username
+export NADEX_PASSWORD=your-password
+nadex_dashboard
+```
+
+#### Method 2: .env File
+Create a `.env` file in your working directory:
+```env
+NADEX_USERNAME=your-username
+NADEX_PASSWORD=your-password
+```
+
+Then run the command as usual:
+```bash
+nadex_dashboard
+```
+
+#### Method 3: Direct Configuration
+```python
+# Custom script using the package
+from nadex_dashboard import NadexClient
+
+client = NadexClient(
+    username="your-username",
+    password="your-password"
+)
+client.start_dashboard()
+```
+
+---
+
+## 🏗️ Architecture & Project Structure
+
+```
+nadex/
+├── nadex_dashboard/
+│   ├── __init__.py              # Package initialization
+│   ├── config.py                # Configuration and environment handling
+│   ├── helpers.py               # Utility functions and data processing
+│   ├── messages.py              # WebSocket message formats and protocols
+│   ├── parsing.py               # Market data parsing and validation
+│   ├── dashboard.py             # CLI formatting and display logic
+│   ├── websocket_manager.py     # WebSocket connection management
+│   └── __main__.py              # CLI entry point
+├── setup.py                     # Package configuration
+├── requirements.txt             # Dependencies
+├── README.md                    # This file
+└── LICENSE                      # MIT License
+```
+
+---
+
+## 📊 Market Data Specifications
+
+### Supported Instruments
+- **EUR/USD** - Euro vs US Dollar
+- **GBP/USD** - British Pound vs US Dollar  
+- **USD/JPY** - US Dollar vs Japanese Yen
+- **AUD/USD** - Australian Dollar vs US Dollar
+- **USD/CAD** - US Dollar vs Canadian Dollar
+- **EUR/JPY** - Euro vs Japanese Yen
+- **GBP/JPY** - British Pound vs Japanese Yen
+
+---
+
+### Local Development Setup
+```bash
+# Clone the repository
+git clone https://github.com/shivamgarg-dev/nadex-dashboard.git
+cd nadex-dashboard
+
+# Install in development mode
+pip install -e .
+
+# Run tests
+python -m pytest tests/
+
+# Run the CLI
+nadex_dashboard
+```
+
+---
+
+## ❓ Frequently Asked Questions
+
+### General Questions
+
+**Q: Is this connected to real money?**
+A: By default, no. The package uses Nadex's test environment with demo credentials. No real funds are involved unless you explicitly provide your own production credentials.
+
+**Q: Do I need a Nadex account?**
+A: No, the package works out-of-the-box with built-in test credentials. However, you can use your own Nadex account if you prefer.
+
+**Q: Is the data real-time?**
+A: Yes, the data is streamed live via WebSocket from Nadex's servers with minimal latency.
+
+### Technical Questions
+
+**Q: Can I use this in trading bots?**
+A: Absolutely. The package is designed with automation in mind. You can import modules and build custom applications on top of it.
+
+**Q: How often does the data update?**
+A: Updates are pushed in real-time as market conditions change, typically 1-5 times per second during active trading hours.
+
+---
+
+## 🗺️ Roadmap
+
+### Upcoming Features
+- [ ] **Historical data export** for backtesting
+- [ ] **Alert system** for price/volume thresholds
+- [ ] **Multiple timeframes** (1-minute, 15-minute options)
+- [ ] **Advanced filtering** by instrument, strike range, etc.
+- [ ] **REST API mode** for web applications
+- [ ] **Docker container** for easy deployment
+- [ ] **Grafana dashboard** integration
+- [ ] **Telegram/Discord bot** notifications
+
+### Long-term Vision
+- Support for other Nadex instrument types (indices, commodities)
+- Machine learning integration for pattern recognition
+- Advanced analytics and visualization tools
+- Mobile app companion
+
+---
+
+## 👨‍💻 Author & Maintainer
+
+**Shivam Garg**  
+- 🌐 **GitHub**: [@shivamgarg001](https://github.com/shivamgarg001)
+
+---
+
+## ⭐️ Show Your Support
+
+If you find this tool helpful for your trading, development, or learning:
+
+- ⭐ **Star the repository** on GitHub
+- 🍴 **Fork it** to contribute
+- 🐛 **Report issues** to help improve it
+- 💡 **Suggest features** for future releases
+- 📢 **Share it** with others who might benefit
+
+**GitHub Repository**: [https://github.com/shivamgarg001/Nadex]
+
+---
+
+**Happy trading! 📈**

nadex_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+nadex_cli-1.0.0.dist-info/licenses/LICENSE,sha256=3u7cBUwc4t0GRkNpKuqj7M7cKldqG0FRIIgNRHP1_qs,1071
+nadex_dashboard/__init__.py,sha256=_a2dwUetiQjYrOahxY50UOLcXe6VpSgx24pzkD1Z9Ow,27
+nadex_dashboard/__main__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nadex_dashboard/config.py,sha256=iFLZLKwkjhjN5ERKpe66O0ftdSbqGmPnUCzDHl8ehRU,3929
+nadex_dashboard/frontend.py,sha256=QWELbcTebP5KBIuCk-F1MdurykvqHhlTIPWcDEL_sAI,2826
+nadex_dashboard/helpers.py,sha256=VueSqwUCQg698XDjKe2mVevJVSlX6NhEKF7nNz2TY3E,3906
+nadex_dashboard/main.py,sha256=0KA7gzktuJ5PbLnK6DRN5A4cJosZCfAeYB38Ia6ZcnM,2868
+nadex_dashboard/messages.py,sha256=v3sTlpJBMm2gzqU2a_2oOxaOXCkgvSrmRnfM30zES-g,7157
+nadex_dashboard/parsing.py,sha256=KwcVUh549fIlcwihtmxOh6XyVncBJRCgB7HtVf2K6BA,5130
+nadex_dashboard/websocket_manager.py,sha256=ufB7HUp4j5P5YZi_cYf_tzjtqKYN5YVH3qZMlVFM4hw,8224
+nadex_cli-1.0.0.dist-info/METADATA,sha256=1HUOJveb2hb0ssWfTrmoAn1mYnrxUbRenpzSo3UQHWY,7130
+nadex_cli-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nadex_cli-1.0.0.dist-info/entry_points.txt,sha256=fLHzipiielS1qZy8tsrK9692ReBsHb327623qr2AF-I,62
+nadex_cli-1.0.0.dist-info/top_level.txt,sha256=xiH5k9agqsuuhDha_9I31BecV6jXHvfkzhOlE-eHKXQ,16
+nadex_cli-1.0.0.dist-info/RECORD,,

nadex_cli-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nadex_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nadex_dashboard = nadex_dashboard:cli_entry

nadex_cli-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2025] [SHIVAM GARG]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nadex_cli-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nadex_dashboard

nadex_dashboard/__init__.py

@@ -0,0 +1 @@
+from .main import cli_entry

nadex_dashboard/config.py

@@ -0,0 +1,105 @@
+# ---------------------------------------------------------------
+# File        : config.py
+# Author      : Shivam Garg
+# Created on  : 27-06-2005
+
+# Copyright (c) Shivam Garg. All rights reserved.
+# ---------------------------------------------------------------
+
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class Config:
+    # Authentication
+    NADEX_USERNAME = os.getenv('NADEX_USERNAME')
+    NADEX_PASSWORD = os.getenv('NADEX_PASSWORD')
+    NADEX_USER_ID = os.getenv('NADEX_USER_ID')
+    
+    # API URLs
+    NADEX_AUTH_URL = os.getenv('NADEX_AUTH_URL')
+    NADEX_SESSION_URL = os.getenv('NADEX_SESSION_URL')
+    NADEX_MARKET_TREE_URL = os.getenv('NADEX_MARKET_TREE_URL')
+    NADEX_NAVIGATION_URL = os.getenv('NADEX_NAVIGATION_URL')
+    FRONTEND_PORT = os.getenv('FRONTEND_PORT')
+    # WebSocket Configuration
+    PING_INTERVAL = int(os.getenv('PING_INTERVAL', 30))
+    RESUBSCRIBE_INTERVAL = int(os.getenv('RESUBSCRIBE_INTERVAL', 300))
+    INITIAL_TABLE_COUNTER = int(os.getenv('INITIAL_TABLE_COUNTER', 15))
+    INITIAL_REQ_PHASE_COUNTER = int(os.getenv('INITIAL_REQ_PHASE_COUNTER', 663))
+    WIN_PHASE = int(os.getenv('WIN_PHASE', 63))
+
+# Headers for authentication
+AUTH_HEADERS = {
+    "Accept": "application/json; charset=UTF-8",
+    "Content-Type": "application/json; charset=UTF-8",
+    "Origin": "https://platform.nadex.com",
+    "User-Agent": "Mozilla/5.0",
+    "x-device-user-agent": "vendor=IG | applicationType=Nadex | platform=web | deviceType=phone | version=0.907.0+78b9f706"
+}
+
+# Headers for session creation
+SESSION_HEADERS = {
+    "Content-Type": "application/x-www-form-urlencoded",
+    "Origin": "https://platform.nadex.com",
+    "Referer": "https://platform.nadex.com/",
+    "User-Agent": "Mozilla/5.0"
+}
+
+# Headers for market data requests
+MARKET_HEADERS = {
+    "accept": "application/json; charset=UTF-8",
+    "accept-encoding": "gzip, deflate, br, zstd",
+    "accept-language": "en-US,en;q=0.9,hi;q=0.8",
+    "authorization": "Bearer undefined",
+    "content-type": "application/json; charset=UTF-8",
+    "origin": "https://platform.nadex.com",
+    "priority": "u=1, i",
+    "sec-ch-ua": '"Google Chrome";v="137", "Chromium";v="137", "Not/A)Brand";v="24"',
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"macOS"',
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-site",
+    "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+    "x-device-user-agent": "vendor=IG | applicationType=Nadex | platform=web | deviceType=phone | version=0.907.0+78b9f706"
+}
+
+# Navigation headers
+NAVIGATION_HEADERS = {
+    "accept": "application/json; charset=UTF-8",
+    "accept-encoding": "gzip, deflate, br, zstd",
+    "accept-language": "en-US,en;q=0.9,hi;q=0.8",
+    "content-type": "application/json; charset=UTF-8",
+    "origin": "https://platform.nadex.com",
+    "referer": "https://platform.nadex.com/",
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-site",
+    "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
+    "x-device-user-agent": "vendor=IG | applicationType=Nadex | platform=web | deviceType=phone | version=0.907.0+78b9f706"
+}
+
+def get_auth_payload():
+    """Get authentication payload with credentials from environment"""
+    return {
+        "username": Config.NADEX_USERNAME,
+        "password": Config.NADEX_PASSWORD
+    }
+
+def get_session_payload(xst_token):
+    """Get session creation payload"""
+    return {
+        "LS_phase": "2301",
+        "LS_cause": "new.api",
+        "LS_polling": "true",
+        "LS_polling_millis": "0",
+        "LS_idle_millis": "0",
+        "LS_client_version": "6.1",
+        "LS_adapter_set": "InVisionProvider",
+        "LS_user": Config.NADEX_USER_ID,
+        "LS_password": f"XST-{xst_token}",
+        "LS_container": "lsc"
+    }

nadex_dashboard/frontend.py

@@ -0,0 +1,84 @@
+# ---------------------------------------------------------------
+# File        : frontend.py
+# Author      : Shivam Garg
+# Created on  : 27-06-2005
+
+# Copyright (c) Shivam Garg. All rights reserved.
+# ---------------------------------------------------------------
+
+import asyncio
+import websockets
+import json
+from typing import Set
+
+# Store connected frontend clients
+frontend_clients: Set[websockets.WebSocketServerProtocol] = set()
+
+async def frontend_handler(websocket, path):
+    """Handle frontend WebSocket connections."""
+    frontend_clients.add(websocket)
+    print(f"[+] Frontend client connected: {websocket.remote_address}")
+    
+    try:
+        async for message in websocket:
+            # Handle messages from frontend clients if needed
+            print(f"[FRONTEND] Received: {message}")
+            # Echo back or process as needed
+            await websocket.send(f"Echo: {message}")
+    except websockets.exceptions.ConnectionClosed:
+        print(f"[-] Frontend client disconnected: {websocket.remote_address}")
+    finally:
+        frontend_clients.discard(websocket)
+
+async def relay_to_frontend(message: str):
+    """Relay message to all connected frontend clients."""
+    if not frontend_clients:
+        return
+    
+    # Create a copy of the set to avoid modification during iteration
+    clients_copy = frontend_clients.copy()
+    
+    # Send to all connected clients
+    disconnected_clients = []
+    for client in clients_copy:
+        try:
+            await client.send(message)
+        except websockets.exceptions.ConnectionClosed:
+            disconnected_clients.append(client)
+        except Exception as e:
+            print(f"[ERROR] Failed to send to frontend client: {e}")
+            disconnected_clients.append(client)
+    
+    # Remove disconnected clients
+    for client in disconnected_clients:
+        frontend_clients.discard(client)
+
+async def broadcast_to_frontend(data: dict):
+    """Broadcast structured data to frontend clients."""
+    message = json.dumps(data)
+    await relay_to_frontend(message)
+
+def get_frontend_client_count() -> int:
+    """Get the number of connected frontend clients."""
+    return len(frontend_clients)
+
+async def close_all_frontend_connections():
+    """Close all frontend connections gracefully."""
+    if not frontend_clients:
+        return
+    
+    print(f"[+] Closing {len(frontend_clients)} frontend connections...")
+    
+    # Create a copy to avoid modification during iteration
+    clients_copy = frontend_clients.copy()
+    
+    # Close all connections
+    for client in clients_copy:
+        try:
+            await client.close()
+        except Exception as e:
+            print(f"[ERROR] Failed to close frontend client: {e}")
+    
+    # Clear the set
+    frontend_clients.clear()
+    print("[+] All frontend connections closed.")

nadex_dashboard/helpers.py

@@ -0,0 +1,117 @@
+# ---------------------------------------------------------------
+# File        : helpers.py
+# Author      : Shivam Garg
+# Created on  : 27-06-2005
+
+# Copyright (c) Shivam Garg. All rights reserved.
+# ---------------------------------------------------------------
+
+import requests
+import re
+from collections import defaultdict
+
+from .config import (
+    Config,
+    AUTH_HEADERS,
+    SESSION_HEADERS,
+    MARKET_HEADERS,
+    NAVIGATION_HEADERS,
+    get_auth_payload,
+    get_session_payload,
+)
+
+# Global XST token
+xst_token = None
+
+def get_xst_token():
+    """Authenticate with Nadex and get XST token."""
+    global xst_token
+    print("[+] Authenticating with Nadex...")
+    resp = requests.post(
+        Config.NADEX_AUTH_URL,
+        json=get_auth_payload(),
+        headers=AUTH_HEADERS
+    )
+    resp.raise_for_status()
+    token = resp.headers.get("x-security-token")
+    if not token:
+        raise RuntimeError("Missing x-security-token")
+    xst_token = token
+    print(f"[+] Obtained XST token: {token[:20]}…")
+    return token
+
+def get_session_info():
+    """Create Lightstreamer session and return session info."""
+    get_xst_token()
+    print("[+] Creating Lightstreamer session…")
+    resp = requests.post(
+        Config.NADEX_SESSION_URL,
+        data=get_session_payload(xst_token),
+        headers=SESSION_HEADERS
+    )
+    resp.raise_for_status()
+    body = resp.text
+    sid = re.search(r"start\('([^']+)'", body).group(1)
+    host = re.search(r"start\('[^']+',\s*'([^']+)'", body).group(1)
+    phase = re.search(r"setPhase\((\d+)\);", body).group(1)
+    return sid, host, int(phase)
+
+def fetch_market_tree():
+    """Fetch market tree from Nadex API."""
+    if not xst_token:
+        raise RuntimeError("xst_token not set")
+    print("[+] Fetching market tree…")
+    hdrs = {k: v for k, v in MARKET_HEADERS.items() if not k.startswith(":")}
+    hdrs["x-security-token"] = xst_token
+    resp = requests.get(Config.NADEX_MARKET_TREE_URL, headers=hdrs)
+    resp.raise_for_status()
+    print(f"[+] Market Tree status: {resp.status_code}")
+    return resp.json()
+
+def extract_forex_ids(tree):
+    """Extract forex market IDs from market tree."""
+    for node in tree.get("topLevelNodes", []):
+        if node.get("name", "").lower() == "5 minute binaries":
+            for c in node.get("children", []):
+                if c.get("name", "").lower() == "forex":
+                    return [x["id"] for x in c.get("children", [])]
+    return []
+
+def fetch_navigation_by_id(mid):
+    """Fetch navigation data for a specific market ID."""
+    url = f"{Config.NADEX_NAVIGATION_URL}/{mid}"
+    hdrs = NAVIGATION_HEADERS.copy()
+    hdrs["x-security-token"] = xst_token
+    resp = requests.get(url, headers=hdrs)
+    resp.raise_for_status()
+    return resp.json()
+
+def map_market_data(fx_ids):
+    """Map market data from forex IDs to underlying epics."""
+    mapping = defaultdict(lambda: defaultdict(list))
+    for mid in fx_ids:
+        print(f"⟳ Processing market ID {mid}")
+        nav = fetch_navigation_by_id(mid)
+        for m in nav.get("markets", []):
+            ue = m.get("underlyingEpic", "")
+            ep = m.get("epic", "")
+            if ue and ep:
+                mapping[mid][ue].append(ep)
+        print(f"  → Found {len(nav.get('markets', []))} epics")
+    return mapping
+
+def print_market_mapping(mapping):
+    """Print a summary of the market mapping."""
+    print("\n" + "=" * 50 + "\nMARKET MAPPING SUMMARY\n" + "=" * 50)
+    total_under, total_ep = 0, 0
+    for mid, ueps in mapping.items():
+        print(f"Market ID {mid}:")
+        for ue, eps in ueps.items():
+            print(f"  • {ue}: {len(eps)} epics")
+            total_under += 1
+            total_ep += len(eps)
+    print(f"\n[+] {len(mapping)} markets, {total_under} underlyings, {total_ep} total epics")
+
+def get_current_xst_token():
+    """Get the current XST token."""
+    return xst_token

nadex_dashboard/main.py

@@ -0,0 +1,95 @@
+# ---------------------------------------------------------------
+# File        : main.py
+# Author      : Shivam Garg
+# Created on  : 27-06-2005
+
+# Copyright (c) Shivam Garg. All rights reserved.
+# ---------------------------------------------------------------
+
+import asyncio
+import signal
+import sys
+import websockets
+import contextlib
+
+from .config import Config
+from .helpers import get_session_info, fetch_market_tree, extract_forex_ids, map_market_data, print_market_mapping
+from .websocket_manager import WebSocketManager
+from .frontend import frontend_handler, close_all_frontend_connections
+
+# Global shutdown event
+shutdown_event = asyncio.Event()
+
+def signal_handler(signum, frame):
+    """Handle shutdown signals gracefully."""
+    print(f"\n[!] Received signal {signum}. Initiating graceful shutdown...")
+    shutdown_event.set()
+
+async def main():
+    """Main application entry point."""
+    # Set up signal handlers
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    
+    # 1) Start frontend server
+    server = await websockets.serve(frontend_handler, "0.0.0.0", Config.FRONTEND_PORT)
+    print(f"[+] Frontend WS listening on ws://0.0.0.0:{Config.FRONTEND_PORT}")
+
+    try:
+        # 2) Get session info and market data
+        sid, host, phase = get_session_info()
+        print(f"[+] Session={sid} phase={phase+2} host={host}")
+
+        tree = fetch_market_tree()
+        fx_ids = extract_forex_ids(tree)
+        if not fx_ids:
+            print("[-] No forex IDs found, exiting.")
+            return
+
+        mapping = map_market_data(fx_ids)
+        print_market_mapping(mapping)
+
+        # 3) Start WebSocket manager
+        mgr = WebSocketManager(sid, phase, host, mapping, fx_ids, shutdown_event)
+        nadex_task = asyncio.create_task(mgr.listen_and_relay())
+
+        # 4) Wait for shutdown signal
+        await shutdown_event.wait()
+        print("\n[!] Shutdown requested — cleaning up…")
+
+        # 5) Cancel WebSocket manager
+        nadex_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await nadex_task
+
+    except Exception as e:
+        print(f"[ERROR] {e}")
+        raise
+    finally:
+        # 6) Close all connections
+        await close_all_frontend_connections()
+        server.close()
+        await server.wait_closed()
+        print("[+] All done. Bye.")
+
+def cli_entry():
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\n[!] Interrupted by user")
+    except Exception as e:
+        print(f"[ERROR] {e}")
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\n[!] Interrupted by user")
+    except Exception as e:
+        print(f"[ERROR] {e}")
+        sys.exit(1)
+    else:
+        sys.exit(0)

nadex_dashboard/messages.py

@@ -0,0 +1,154 @@
+# ---------------------------------------------------------------
+# File        : messages.py
+# Author      : Shivam Garg
+# Created on  : 27-06-2005
+
+# Copyright (c) Shivam Garg. All rights reserved.
+# ---------------------------------------------------------------
+
+from .config import Config
+
+class WebSocketMessages:
+    """Class to handle all WebSocket message templates"""
+    
+    @staticmethod
+    def get_bind_session_message(session_id, phase):
+        """Generate bind session message (Table 1)"""
+        return (
+            "bind_session\r\n"
+            f"LS_session={session_id}&LS_phase={phase}&LS_cause=loop1&LS_container=lsc&control\r\n"
+            f"LS_mode=RAW&LS_id=M___.HB%7CHB.U.HEARTBEAT.IP&LS_schema=HEARTBEAT&"
+            f"LS_requested_max_frequency=1&LS_table=1&LS_req_phase=619&LS_win_phase=50&LS_op=add&LS_session={session_id}&"
+        )
+    
+    @staticmethod
+    def get_core_subscriptions(session_id, user_id):
+        """Generate core subscription messages (Tables 2-7)"""
+        return [
+            # Table 2 - Message Event Handler
+            f"control\r\nLS_mode=RAW&LS_id=V2-M-MESSAGE_EVENT_HANDLER%7C{user_id}&LS_schema=message&"
+            f"LS_requested_max_frequency=1&LS_table=2&LS_req_phase=620&LS_win_phase=50&LS_op=add&LS_session={session_id}&",
+
+            # Table 3 - Account Balance
+            f"control\r\nLS_mode=MERGE&LS_id=V2-AD-AC_AVAILABLE_BALANCE%2CAC_USED_MARGIN%7CACC.{user_id}&"
+            f"LS_schema=AC_AVAILABLE_BALANCE%20AC_USED_MARGIN&LS_snapshot=true&LS_requested_max_frequency=1&"
+            f"LS_table=3&LS_req_phase=621&LS_win_phase=50&LS_op=add&LS_session={session_id}&",
+
+            # Table 4 - Message Event Handler JSON
+            f"control\r\nLS_mode=RAW&LS_id=V2-M-MESSAGE_EVENT_HANDLER%7C{user_id}-OP-JSON&LS_schema=json&"
+            f"LS_requested_max_frequency=1&LS_table=4&LS_req_phase=622&LS_win_phase=50&LS_op=add&LS_session={session_id}&",
+
+            # Table 5 - MGE
+            f"control\r\nLS_mode=RAW&LS_id=M___.MGE%7C{user_id}-LGT&LS_schema=message&"
+            f"LS_requested_max_frequency=1&LS_table=5&LS_req_phase=623&LS_win_phase=50&LS_op=add&LS_session={session_id}&",
+
+            # Table 6 - WO JSON
+            f"control\r\nLS_mode=RAW&LS_id=V2-M-MESSAGE_EVENT_HANDLER%7C{user_id}-WO-JSON&LS_schema=json&"
+            f"LS_requested_max_frequency=1&LS_table=6&LS_req_phase=624&LS_win_phase=50&LS_op=add&LS_session={session_id}&",
+
+            # Table 7 - OH JSON
+            f"control\r\nLS_mode=RAW&LS_id=V2-M-MESSAGE_EVENT_HANDLER%7C{user_id}-OH-JSON&LS_schema=json&"
+            f"LS_requested_max_frequency=1&LS_table=7&LS_req_phase=625&LS_win_phase=50&LS_op=add&LS_session={session_id}&"
+        ]
+    
+    @staticmethod
+    def get_binary_fx_subscriptions(session_id):
+        """Generate binary FX pairs subscriptions (Tables 8-14)"""
+        pairs = [
+            ("8", "SAUDUSD"),
+            ("9", "SEURUSD"),
+            ("10", "SGBPUSD"),
+            ("11", "SUSDJPY"),
+            ("12", "SEURJPY"),
+            ("13", "SGBPJPY"),
+            ("14", "SUSDCAD"),
+        ]
+        
+        messages = []
+        for table, symbol in pairs:
+            phase_val = str(625 + int(table))
+            msg = (
+                "control\r\n"
+                f"LS_mode=MERGE&LS_id=V2-F-LTP%2CUTM%7CCH.U.X%3A{symbol}:1321%3ABLD.OPT-1-1.IP&"
+                "LS_schema=lastTradedPrice%20updateTime&LS_snapshot=true&LS_requested_max_frequency=1&"
+                f"LS_table={table}&LS_req_phase={phase_val}&LS_win_phase=50&LS_op=add&LS_session={session_id}&"
+            )
+            messages.append(msg)
+        
+        return messages
+    
+    @staticmethod
+    def get_strike_message_type1(session_id, encoded_epic, table_counter, req_phase_counter, win_phase):
+        """Generate strike subscription message type 1"""
+        return (
+            "control\r\n"
+            f"LS_mode=MERGE&LS_id=V2-F-BD1%2CAK1%2CBS1%2CAS1%2CUTM%2CDLY%2CUBS%2CSWAP_3_SHORT%2CSWAP_3_LONG%7C{encoded_epic}&"
+            "LS_schema=displayOffer%20displayBid%20bidSize%20offerSize%20updateTime%20delayTime%20marketStatus%20swapPointSell%20swapPointBuy&"
+            f"LS_snapshot=true&LS_requested_max_frequency=1&LS_table={table_counter}&"
+            f"LS_req_phase={req_phase_counter}&LS_win_phase={win_phase}&LS_op=add&LS_session={session_id}&"
+        )
+    
+    @staticmethod
+    def get_strike_message_type2(session_id, encoded_epic, table_counter, req_phase_counter, win_phase):
+        """Generate strike subscription message type 2 (BID/ASK)"""
+        return (
+            "control\r\n"
+            f"LS_mode=MERGE&LS_id=V2-F-BD1%2CAK1%2CBS1%2CAS1%2CBD2%2CAK2%2CBS2%2CAS2%2CBD3%2CAK3%2CBS3%2CAS3%2CBD4%2CAK4%2CBS4%2CAS4%2CBD5%2CAK5%2CBS5%2CAS5%7C{encoded_epic}&"
+            "LS_schema=displayOffer%20displayBid%20bidSize%20offerSize%20displayOffer2%20displayBid2%20bidSize2%20offerSize2%20displayOffer3%20displayBid3%20bidSize3%20offerSize3%20displayOffer4%20displayBid4%20bidSize4%20offerSize4%20displayOffer5%20displayBid5%20bidSize5%20offerSize5&"
+            f"LS_snapshot=true&LS_requested_max_frequency=1&LS_table={table_counter}&"
+            f"LS_req_phase={req_phase_counter}&LS_win_phase={win_phase}&LS_op=add&LS_session={session_id}&"
+        )
+    
+    @staticmethod
+    def get_hierarchy_message(session_id, forex_id, table_counter, req_phase_counter, win_phase):
+        """Generate hierarchy subscription message"""
+        return (
+            "control\r\n"
+            f"LS_mode=RAW&LS_id=M___.MGE%7CHIER-{forex_id}-JSON&LS_schema=json&"
+            f"LS_requested_max_frequency=1&LS_table={table_counter}&"
+            f"LS_req_phase={req_phase_counter}&LS_win_phase={win_phase}&LS_op=add&LS_session={session_id}&"
+        )
+    
+    @staticmethod
+    def get_ping_message(session_id, phase):
+        """Generate ping/keepalive message"""
+        return (
+            f"control\r\nLS_op=constrain&LS_session={session_id}&LS_phase={phase}&LS_cause=keepalive&"
+            f"LS_polling=true&LS_polling_millis=0&LS_idle_millis=0&LS_container=lsc&"
+        )
+
+class MessageTable:
+    """Class to display message information in a table format"""
+    
+    def __init__(self):
+        self.messages = []
+    
+    def add_message(self, message_type, table_id, description, epic=None):
+        """Add a message to the table"""
+        self.messages.append({
+            'type': message_type,
+            'table': table_id,
+            'description': description,
+            'epic': epic or 'N/A'
+        })
+    
+    def print_table(self):
+        """Print the message table"""
+        print("\n" + "="*100)
+        print("WEBSOCKET MESSAGE SUBSCRIPTION TABLE")
+        print("="*100)
+        print(f"{'Type':<20} {'Table':<8} {'Epic':<30} {'Description':<40}")
+        print("-"*100)
+        
+        for msg in self.messages:
+            print(f"{msg['type']:<20} {msg['table']:<8} {msg['epic']:<30} {msg['description']:<40}")
+        
+        print("-"*100)
+        print(f"Total Messages: {len(self.messages)}")
+        print("="*100)
+    
+    def clear(self):
+        """Clear the message table"""
+        self.messages = []
+
+        

nadex_dashboard/parsing.py

@@ -0,0 +1,158 @@
+# ---------------------------------------------------------------
+# File        : parsing.py
+# Author      : Shivam Garg
+# Created on  : 27-06-2005
+
+# Copyright (c) Shivam Garg. All rights reserved.
+# ---------------------------------------------------------------
+
+import re
+from collections import defaultdict
+
+# Global table to epic mapping
+table_to_epic = {}
+
+# Regex to extract z() and d() calls
+CALL_RE = re.compile(r"(z|d)\(\s*([^)]*?)\s*\)")
+
+def update_table_mapping(epic, table_id, type):
+    """
+    Update the table_to_epic mapping when new subscriptions are made.
+    Call this function whenever you process the subscription table from logs.
+    """
+    global table_to_epic
+    
+    table_to_epic[table_id] = epic + " " + type
+    
+    print(f"[INFO] Updated table mappings for {len(table_to_epic)} tables")
+
+def parse_csv_args(argstr):
+    """
+    Parse comma-separated arguments, handling quoted strings properly.
+    Returns list of cleaned argument strings.
+    """
+    # Handle quoted strings and regular comma separation
+    tokens = re.findall(r"""'[^']*'|[^,]+""", argstr)
+    # Strip whitespace and quotes, convert $ to empty string, # to None representation
+    parts = []
+    for token in tokens:
+        cleaned = token.strip().strip("'")
+        if cleaned == '$':
+            parts.append('')  # Empty value
+        elif cleaned == '#':
+            parts.append(None)  # Null value
+        else:
+            parts.append(cleaned)
+    
+    return [p for p in parts if p is not None]  # Filter out None values
+
+def find_time_field(parts, start_idx=3):
+    """
+    Find the timestamp field in the message parts.
+    Looks for HH:MM:SS pattern starting from start_idx.
+    """
+    for i in range(start_idx, len(parts)):
+        if parts[i] and re.match(r"\d{2}:\d{2}:\d{2}", str(parts[i])):
+            return i, parts[i]
+    return None, None
+
+def process_forex_prices(msg: str):
+    """
+    Process underlying forex price updates (tables 8-14).
+    These are the base currency pair prices that affect all options.
+    """
+    # Look for d() calls on tables 8-14 (forex underlying prices)
+    forex_tables = {
+        8: "AUD/USD",
+        9: "EUR/USD", 
+        10: "GBP/USD",
+        11: "USD/JPY",
+        12: "EUR/JPY",
+        13: "GBP/JPY", 
+        14: "USD/CAD"
+    }
+    
+    for match in CALL_RE.finditer(msg):
+        call_type, argstr = match.groups()
+        if call_type != 'd':  # Only process updates for forex
+            continue
+            
+        parts = parse_csv_args(argstr)
+        if len(parts) < 3:
+            continue
+            
+        try:
+            tbl = int(parts[0])
+        except (ValueError, TypeError):
+            continue
+            
+        if tbl in forex_tables:
+            price = parts[2] if len(parts) > 2 else "N/A"
+            time_idx, timestamp = find_time_field(parts)
+            if not timestamp:
+                timestamp = "N/A"
+                
+            pair = forex_tables[tbl]
+            print(f"[FOREX] {pair:8} -> {price:>10} @ {timestamp}")
+
+def process_option_prices(msg: str):
+    """
+    Process binary option price updates.
+    """
+    for match in CALL_RE.finditer(msg):
+        call_type, argstr = match.groups()
+        parts = parse_csv_args(argstr)
+        
+        if len(parts) < 3:
+            continue
+            
+        try:
+            tbl = int(parts[0])
+        except (ValueError, TypeError):
+            continue
+            
+        epic = table_to_epic.get(tbl)
+        if not epic:
+            continue  # Not one of our tracked option tables
+            
+        # Extract key information
+        item = parts[1] if len(parts) > 1 else "1"
+        price = parts[2] if len(parts) > 2 else "N/A"
+        
+        # For z() calls, bid/ask are typically in positions 2,3
+        # For d() calls, structure can vary
+        if call_type == "z":
+            # Initial price setting: z(tbl, item, bid, ask, size1, size2, time, ...)
+            bid = parts[2] if len(parts) > 2 else "N/A"
+            ask = parts[3] if len(parts) > 3 else "N/A" 
+            time_idx, timestamp = find_time_field(parts, 4)
+            tag = "INIT"
+        else:  # 'd' call
+            # Price update: d(tbl, item, price, [other_fields...], time, [more_fields...])
+            bid = parts[2] if len(parts) > 2 else "N/A"
+            ask = parts[3] if len(parts) > 3 else "N/A"
+            time_idx, timestamp = find_time_field(parts)
+            tag = "UPDATE"
+            
+        if not timestamp:
+            timestamp = "N/A"
+            
+        # Clean up epic name for display
+        epic_short = epic.replace("NB.I.", "").replace(".IP", "")
+        
+        print(f"[{tag:6}] {epic_short:35} bid={bid:>6} ask={ask:>6} @ {timestamp}")
+
+def process_message(msg: str):
+    """
+    Main message processor that handles both forex and option updates.
+    """
+    # Process forex underlying prices first
+    process_forex_prices(msg)
+    
+    # Then process option prices
+    process_option_prices(msg)
+
+def clear_table_mapping():
+    """Clear the global table_to_epic mapping."""
+    global table_to_epic
+    table_to_epic.clear()

nadex_dashboard/websocket_manager.py

@@ -0,0 +1,197 @@
+# ---------------------------------------------------------------
+# File        : websocket_manager.py
+# Author      : Shivam Garg
+# Created on  : 27-06-2005
+
+# Copyright (c) Shivam Garg. All rights reserved.
+# ---------------------------------------------------------------
+
+import asyncio
+import datetime
+import time
+import websockets
+from collections import defaultdict
+
+from .config import Config
+from nadex_dashboard.messages import WebSocketMessages, MessageTable
+from .parsing import update_table_mapping, clear_table_mapping, process_message
+from .frontend import relay_to_frontend
+from .helpers import fetch_market_tree, extract_forex_ids, map_market_data
+
+class WebSocketManager:
+    """Manages WebSocket connections and subscriptions to Nadex."""
+    
+    def __init__(self, session_id, phase, host, market_mapping, forex_ids, shutdown_event):
+        self.session = session_id
+        self.phase = phase + 2
+        self.host = host
+        self.mapping = market_mapping
+        self.fx_ids = forex_ids
+        self.shutdown_event = shutdown_event
+
+        self.table_counter = Config.INITIAL_TABLE_COUNTER
+        self.req_phase_counter = Config.INITIAL_REQ_PHASE_COUNTER
+        self.win_phase = Config.WIN_PHASE
+
+        self.last_ping = time.time()
+        self.ping_interval = Config.PING_INTERVAL
+
+        self.message_table = MessageTable()
+
+    async def send_initial_subscriptions(self, ws):
+        """Send initial subscription messages."""
+        print("[+] Sending initial subscriptions…")
+        self.message_table.clear()
+        
+        # bind_session
+        msg = WebSocketMessages.get_bind_session_message(self.session, self.phase)
+        await ws.send(msg)
+        self.message_table.add_message("BIND", 1, "Session bind")
+        await asyncio.sleep(0.1)
+
+        # core (2–7)
+        core = WebSocketMessages.get_core_subscriptions(self.session, Config.NADEX_USER_ID)
+        for i, m in enumerate(core, start=2):
+            await ws.send(m)
+            self.message_table.add_message("CORE", i, f"Core idx {i}")
+            await asyncio.sleep(0.1)
+
+        # binary FX (8–14)
+        bins = WebSocketMessages.get_binary_fx_subscriptions(self.session)
+        for idx, m in enumerate(bins, start=8):
+            await ws.send(m)
+            self.message_table.add_message("BINARY", idx, f"Bin idx {idx}")
+            await asyncio.sleep(0.1)
+
+        print(f"[+] Done init (1–14)")
+
+    async def send_strike_subscriptions(self, ws):
+        """Send strike subscription messages."""
+        print(f"[+] Starting strike subs at table {self.table_counter}")
+        count = 0
+        for mid, ueps in self.mapping.items():
+            for ue, eps in ueps.items():
+                for epic in eps:
+                    if self.shutdown_event.is_set():
+                        return
+                    
+                    update_table_mapping(epic, self.table_counter, "STRIKE")
+                    
+                    enc = epic.replace(".", "%2E").replace("-", "%2D")
+                    m1 = WebSocketMessages.get_strike_message_type1(
+                        self.session, enc, self.table_counter, self.req_phase_counter, self.win_phase
+                    )
+                    await ws.send(m1)
+                    self.message_table.add_message("STRIKE1", self.table_counter, epic)
+                    self.table_counter += 1
+                    self.req_phase_counter += 1
+                    await asyncio.sleep(0.05)
+                    
+                    update_table_mapping(epic, self.table_counter, "ORDERBOOK")
+                    m2 = WebSocketMessages.get_strike_message_type2(
+                        self.session, enc, self.table_counter, self.req_phase_counter, self.win_phase
+                    )
+                    await ws.send(m2)
+                    self.message_table.add_message("STRIKE2", self.table_counter, epic)
+                    self.table_counter += 1
+                    self.req_phase_counter += 1
+                    await asyncio.sleep(0.05)
+                    count += 1
+        print(f"[+] Sent {count} strike subs")
+
+    async def send_hierarchy_subscriptions(self, ws):
+        """Send hierarchy subscription messages."""
+        print(f"[+] Starting hierarchy subs at table {self.table_counter}")
+        for fid in self.fx_ids:
+            if self.shutdown_event.is_set():
+                return
+            m = WebSocketMessages.get_hierarchy_message(
+                self.session, fid, self.table_counter, self.req_phase_counter, self.win_phase
+            )
+            await ws.send(m)
+            self.message_table.add_message("HIER", self.table_counter, fid)
+            self.table_counter += 1
+            self.req_phase_counter += 1
+            await asyncio.sleep(0.1)
+        print(f"[+] Sent {len(self.fx_ids)} hierarchy subs")
+
+    async def handle_ping_pong(self, ws):
+        """Handle ping/pong messages to keep connection alive."""
+        while not self.shutdown_event.is_set():
+            if time.time() - self.last_ping >= self.ping_interval:
+                ping = WebSocketMessages.get_ping_message(self.session, self.phase)
+                await ws.send(ping)
+                self.last_ping = time.time()
+                print(f"[PING] @ {time.strftime('%H:%M:%S')}")
+            try:
+                await asyncio.wait_for(self.shutdown_event.wait(), timeout=1.0)
+                break
+            except asyncio.TimeoutError:
+                continue
+
+    async def resubscribe_instruments(self, ws):
+        """Periodically resubscribe to instruments."""
+        while not self.shutdown_event.is_set():
+            now = datetime.datetime.now()
+            # next 5-min mark
+            nxt = ((now.minute // 5) + 1) * 5
+            if nxt >= 60:
+                nxt_time = now.replace(hour=now.hour + 1, minute=0, second=0, microsecond=0)
+            else:
+                nxt_time = now.replace(minute=nxt, second=0, microsecond=0)
+            wait = (nxt_time - now).total_seconds()
+            print(f"[TIMER] wait {int(wait)}s until {nxt_time.strftime('%H:%M:%S')}")
+            try:
+                await asyncio.wait_for(self.shutdown_event.wait(), timeout=wait)
+                break
+            except asyncio.TimeoutError:
+                pass
+            if self.shutdown_event.is_set():
+                break
+
+            print(f"[RESUB] @ {datetime.datetime.now().strftime('%H:%M:%S')}")
+            tree = fetch_market_tree()
+            fx_ids = extract_forex_ids(tree)
+            if not fx_ids:
+                print("[-] none found on resub")
+                continue
+            self.mapping = map_market_data(fx_ids)
+            clear_table_mapping()  # Clear old mappings
+            await self.send_strike_subscriptions(ws)
+
+    async def listen_and_relay(self):
+        """Main WebSocket listener that relays messages."""
+        uri = f"wss://{self.host}/lightstreamer"
+        async with websockets.connect(uri, subprotocols=["js.lightstreamer.com"]) as nadex_ws:
+            await self.send_initial_subscriptions(nadex_ws)
+            self.message_table.print_table()
+
+            await self.send_strike_subscriptions(nadex_ws)
+            await self.send_hierarchy_subscriptions(nadex_ws)
+            self.message_table.print_table()
+
+            # Start background tasks
+            ping_task = asyncio.create_task(self.handle_ping_pong(nadex_ws))
+            resub_task = asyncio.create_task(self.resubscribe_instruments(nadex_ws))
+
+            print("[+] Relaying Nadex → Frontends…")
+            async for msg in nadex_ws:
+                if self.shutdown_event.is_set():
+                    break
+                    
+                # Detect PONG
+                if "PONG" in msg.upper():
+                    print(f"[PONG] @ {time.strftime('%H:%M:%S')}")
+                    
+                # Relay to frontend and process message
+                await relay_to_frontend(msg)
+                process_message(msg)
+
+            # Clean up background tasks
+            ping_task.cancel()
+            resub_task.cancel()
+            try:
+                await ping_task
+                await resub_task
+            except asyncio.CancelledError:
+                pass