How fardu6288/trade_bot works
This is a semi-automated trading system:
• Web UI (static HTML/JS) used by a human to review signals and approve trades
• FastAPI backend that:
• fetches market data
• runs indicator-based strategy (SMA/EMA crossovers)
• validates risk constraints (balance + price bounds)
• places orders via Zerodha KiteConnect API
• “Semi-automated” (human-in-the-loop) is the core architectural constraint: signals can be automatic, execution is gated by user approval.
• the approval gate
• the broker integration boundary
• the data-flow: watchlist → data → indicators/strategy → signal → UI → validate → order
Use the repo structure to “explode” the system into accurate components:
Frontend (Browser)
Files: frontend/index.html, frontend/script.js, frontend/style.css
Role:
• Renders signal list / candidate buys
• Collects user inputs (qty, min/max buy price)
• Calls backend endpoints (likely REST over HTTP)
Backend API layer (FastAPI)
Files: backend/main.py, backend/api.py
Role:
• Defines HTTP endpoints for:
• login/session initiation/redirect (Zerodha auth)
• fetching balance
• fetching signals
• placing an order after user approval
Strategy / Indicators engine
Files: backend/strategy.py, backend/indicators.py, backend/instruments.py
Role:
• Strategy orchestration (SMA/EMA crossover selection)
• Indicator computations
• Instrument metadata / symbol mappings
Market data acquisition
Files: backend/data_provider.py
Role:
• Fetches historical/market data used by strategy computations
• Source is likely Zerodha endpoints (or a KiteConnect method)
Broker session & trading execution
Files: backend/zerodha_session.py, backend/zerodha_trader.py
Role:
• Auth/session lifecycle with Zerodha (token, login)
• Order placement + balance fetching
• Session/Auth Manager
• Order Execution / Portfolio & Balance
Configuration + watchlist
Files: config/config.yaml, config/watchlist.json, backend/config_loader.py, .env
Role:
• Watchlist is the input universe for scanning
• Config controls strategy params, limits, environment settings
Persistence / artifacts / logs (supporting components)
Files: logs/app.log, logs/trades.log, models/trading_model.pkl, models/scaler.pkl
Role:
• Logs: observability + audit trail (especially trades.log)
• Logging / Audit Trail
• Model Artifacts (Optional)
External system
External: Zerodha Kite API (plus “Live Market & Orders” behind it)
Safety/controls (must be visible)
• An explicit “Human Approval Gate” between Signal Generation and Order Execution.
• Available balance validation
• Min/max buy price validation
Architectural patterns / principles to call out
• Layered architecture: UI → API → domain (strategy) → integration (broker).
• Human-in-the-loop control: order placement is not triggered by strategy; it is triggered by a user action.
• Integration boundary: Zerodha is an external dependency; isolate it behind zerodha_session.py and zerodha_trader.py.
• Configuration-driven scanning: watchlist/config define what is scanned and how.
• User (Trader)
• Browser Frontend
• FastAPI Backend
• Zerodha Kite API (External)
• User ↔ Browser
• Browser ↔ FastAPI (HTTP)
• FastAPI ↔ Zerodha (KiteConnect)
• FastAPI → Logs
• API Routes (api.py)
• Strategy Engine (strategy.py)
• Indicators (indicators.py)
• Data Provider (data_provider.py)
• Zerodha Session (zerodha_session.py)
• Zerodha Trader (zerodha_trader.py)
• Config Loader (config_loader.py)
• Logging (writes to logs/)
Externalized stores:
• Config files (config.yaml, watchlist.json, .env)
• Model artifacts (models/*.pkl) as optional dependency if referenced
Exact gating:
• UI requests signals
• backend fetches data → computes indicators → returns signals
• user approves trade
• backend validates constraints
• backend places order
• backend logs trade
What to label explicitly (to avoid ambiguity)
• Protocols: “HTTP (REST)” between Browser and FastAPI
• External SDK: “KiteConnect SDK / Zerodha API”
• Artifacts: “watchlist.json”, “config.yaml”, “.env”
• Outputs: “BUY signals”, “Order request”, “Order status”
• Constraints: “Manual approval required”, “Balance check”, “Min/Max price validation”
“As-many-components-as-possible” decomposition (practical checklist)
When drawing, separate at least into:
• Frontend UI
• FastAPI app + routing
• Signal generation pipeline:
• watchlist loading
• market data retrieval
• indicator calculation
• strategy decision
• Trade approval + inputs
• Validation (balance + price bounds)
• Order execution
• Session/auth management
• Logging/audit
• External broker API