lightweight-charts-python

The PolygonAPI class is integrated into all chart types via the chart.polygon attribute. You can use it to fetch and display stock, option, index, forex, or crypto data directly on your chart.

Common Parameters for all methods:

• timeframe: The interval (e.g., '1min', '5min', 'H', '2D', '5W').
• start_date: Start date in YYYY-MM-DD format.
• end_date: End date in YYYY-MM-DD format (defaults to 'now').
• limit: Maximum number of base aggregates to query.
• live: Set to True to use a websocket connection for real-time updates.

Important Requirements:

• If live=True, you must install the websockets library.
• When using live data with the standard show method, you must set block=True (i.e., chart.show(block=True)) to allow data to congregate on the chart. Alternatively, use show_async.

Note: Methods return a boolean indicating if the request was successful.

from lightweight_charts import Chart

if __name__ == '__main__':
    chart = Chart()
    chart.polygon.api_key('<API-KEY>')
    chart.polygon.stock(
        symbol='AAPL',
        timeframe='5min',
        start_date='2023-06-09'
    )
    chart.show(block=True)

To run custom logic (like a clock or a live data feed) while the GUI loop is active and listening for events, you should use chart.show_async() within an asyncio event loop.

Use asyncio.gather() to run the chart's display loop and your background task concurrently. Always check chart.is_alive within your background loops to ensure they exit gracefully when the chart is closed.

import asyncio
from datetime import datetime
from lightweight_charts import Chart

async def update_clock(chart):
    while chart.is_alive:
        # Sleep until the next second
        await asyncio.sleep(1-(datetime.now().microsecond/1_000_000))
        chart.topbar['clock'].set(datetime.now().strftime('%H:%M:%S'))

async def main():
    chart = Chart()
    chart.topbar.textbox('clock')
    # Run the chart and the clock task concurrently
    await asyncio.gather(chart.show_async(), update_clock(chart))

if __name__ == '__main__':
    asyncio.run(main())

The toolbox feature in lightweight-charts-python allows users to create drawings on a chart and persist them using JSON files. To implement persistence, you can manage drawings based on a specific symbol and timeframe, loading them when the symbol changes and exporting them when the chart session ends.

Workflow for Persistence:

1. Initialize: Create an empty drawings.json file (containing {}) to act as your storage.
2. Setup: Initialize the chart with Chart(toolbox=True).
3. Import/Load: Use chart.toolbox.import_drawings('filename.json') to load the storage file, then chart.toolbox.load_drawings(symbol) to load drawings specific to the current symbol.
4. Update Data: When changing timeframes without changing the symbol, use chart.set(new_data, keep_drawings=True) to ensure existing drawings remain visible on the new data.
5. Save/Export: Use chart.toolbox.save_drawings_under(symbol_object) to save current drawings to the internal storage, and chart.toolbox.export_drawings('filename.json') to write the stored drawings to a file (typically called when the chart is closed).

The Chart object provides a topbar interface to add interactive elements like textboxes and switchers. You can respond to user interactions through event registration and callback functions.

Topbar Components

• chart.topbar.textbox(name, default_value): Creates a text input field. You can access its current value via chart.topbar[name].value and update it using .set(new_value).
• chart.topbar.switcher(name, options, default, func): Creates a selection menu. The func parameter accepts a callback that is triggered when the selection changes.

Event Registration

• Search Event: Use chart.events.search += callback_function to listen for search queries initiated in the topbar.
• Component Callbacks: Many UI elements and drawing tools (like horizontal_line) accept a func argument to handle interaction events directly.

import pandas as pd
from lightweight_charts import Chart

def on_search(chart, searched_string):
    # Access topbar values and update them
    current_timeframe = chart.topbar['timeframe'].value
    chart.topbar['symbol'].set(searched_string)
    # chart.set(new_data) to update the chart

def on_timeframe_selection(chart):
    # Triggered by switcher
    symbol = chart.topbar['symbol'].value
    timeframe = chart.topbar['timeframe'].value
    # chart.set(new_data, True) to update the chart

def on_horizontal_line_move(chart, line):
    print(f'Horizontal line moved to: {line.price}')

if __name__ == '__main__':
    chart = Chart(toolbox=True)
    
    # Register search event
    chart.events.search += on_search

    # Configure Topbar
    chart.topbar.textbox('symbol', 'TSLA')
    chart.topbar.switcher('timeframe', ('1min', '5min', '30min'), default='5min', 
                          func=on_timeframe_selection)

    # Add interactive drawing tool with callback
    chart.horizontal_line(200, func=on_horizontal_line_move)

    chart.show(block=True)