Skip to content

Latest commit

 

History

History
145 lines (116 loc) · 6.59 KB

README.md

File metadata and controls

145 lines (116 loc) · 6.59 KB

Trading Automation System with KiteConnect

This repository contains a Django-based Python application for algorithmic trading. It uses the KiteConnect API to process real-time market data and manage trades effectively. The application is designed to operate autonomously, integrating advanced strategies, order management, and profit/loss tracking. It includes robust logging and error handling for reliable performance in live trading environments.

Key Features

1. Real-time Market Data Processing

  • Utilizes KiteConnect's WebSocket API (KiteTicker) for real-time tick data streaming.
  • Processes tick data for a list of specified instruments, allowing efficient trade execution.
  • Includes the WebSocketHandler class for:
    • Establishing and managing WebSocket connections.
    • Reconnecting in case of network issues or connection drops.
    • Handling and processing received tick data.

2. Candle Aggregation

  • Implements the CandleAggregator class to:
    • Aggregate tick data into OHLC (Open-High-Low-Close) candles at configurable time intervals.
    • Save aggregated candles to JSON files, ensuring session persistence and traceability.
    • Support multiple instruments, each with its dedicated candle aggregator.

3. Trading Strategy Execution

  • Analyzes aggregated candle data to generate buy/sell signals.
  • Allows customizable trading strategies, including:
    • Percentage-based calculations for entry/exit signals.
    • Custom trailing stop-loss updates to lock in profits dynamically.
    • Reverse order mechanisms for adapting to market trends after a stop-loss is hit.
  • Supports user-defined trade sides:
    • "BOTH": Enables bi-directional trading with reverse orders.
    • "BUY": Restricts trading to BUY positions only.
    • "SELL": Restricts trading to SELL positions only.

4. Order Management

  • Integrates order placement via the KiteConnect API with support for:
    • Market orders.
    • Stop-loss and trailing stop-loss updates.
    • Reverse orders based on stop-loss triggers (when trade_side is set to "BOTH").
  • Tracks active orders to prevent duplicate executions and ensure controlled trading.

5. Profit and Loss Calculation

  • Computes both realized and unrealized profits/losses for the trading day.
  • Monitors cumulative profit/loss and stops trading when a predefined threshold is reached.
  • Includes extensive logging for profit/loss calculations to ensure transparency and debugging ease.
  • Includes a feature to calculate cumulative profit across multiple instruments based on user-defined exit thresholds.

6. Error Handling and Logging

  • Implements structured error handling for:
    • WebSocket errors and reconnection logic.
    • Data validation and processing errors (e.g., missing fields in tick data).
    • Order placement and strategy evaluation issues.
  • Comprehensive logging for:
    • WebSocket connection events.
    • Tick data processing and candle updates.
    • Strategy execution and order placements.
    • Profit/loss tracking and daily trade closures.

Architecture

Main Components

  1. CandleAggregator:

    • Handles tick data aggregation and candle management.
    • Implements trading strategies and stop-loss logic.

  2. WebSocketHandler:

    • Manages WebSocket connections for streaming real-time tick data.
    • Handles reconnection logic and processes tick data using CandleAggregator.

External Dependencies

  • KiteConnect: For accessing market data, placing orders, and managing trades.
  • Redis: (Optional) For caching or state management, though not actively used in the provided script.
  • Python Libraries: Standard and third-party libraries for computations, file handling, logging, and asynchronous operations.

Getting Started

Prerequisites

  • Python 3.x installed.
  • Django framework set up in your environment.
  • API key and access token for KiteConnect.
  • Optional: Redis server for advanced caching.

Installation

  1. Clone the repository: 
    git clone https://github.com/yourusername/trading-automation.git
cd no_indicator_bot
  2. Install dependencies: 
    pip install -r requirements.txt
  3. Configure your API credentials in the appropriate settings file.
  4. Run the Django application: 
    python manage.py runserver

Usage

  1. Define your trading instruments, time intervals, and strategies in the configuration using APIs.
  2. Start the WebSocket connection to receive real-time tick data.
  3. Monitor logs for detailed trade activity, including profit/loss updates, order placements, and stop-loss adjustments.

Advantages

  • Automated Trading: Executes trades autonomously, reducing manual effort.
  • Customizable Strategies: Easily adapt strategies to changing market conditions.
  • Real-time Data Processing: Leverages real-time data for timely trade decisions.
  • Robust Logging and Debugging: Tracks all key events for transparency and troubleshooting.

Contributing

Feel free to fork this repository, submit issues, or create pull requests for new features or bug fixes.

Probable Enhancement: Using Redis for Candle Management

The current implementation uses JSON files to store and read candle data. While functional, this approach may introduce latency in scenarios with high-frequency data or when processing large datasets.

Proposed Enhancement:

  • Redis Integration: Replace JSON-based storage with Redis to manage candle data.
  • Benefits:
    1. Faster Reads and Writes: Redis operates in-memory, providing significantly faster operations compared to file-based storage.
    2. Scalability: Handles higher volumes of tick data efficiently, making it suitable for high-frequency trading scenarios.
    3. Reduced I/O Overhead: Minimizes disk I/O operations, enhancing overall performance.
    4. Data Persistence Options: Redis offers configurable persistence for long-term storage needs.

Implementation Steps:

  1. Use Redis Hashes to store OHLC candles for each instrument.
    • Key: instrument_token:timeframe
    • Fields: open, high, low, close, volume, etc.
  2. Modify the CandleAggregator class to interact with Redis instead of JSON.
  3. Utilize Redis pipelines or transactions to handle bulk updates efficiently.
  4. Incorporate expiry mechanisms (e.g., time-to-live for keys) to clean up outdated data automatically.

This enhancement would align the application with real-time trading demands and make it more robust for live trading environments.

License

This project is licensed under the MIT License.