f72baf95ba
- Added async methods to polygon. - The `requests` library is no longer required, with `urllib` being used instead. - Added the `get_bar_data` function, which returns a dataframe of aggregate data from polygon. - Opened up the `subscribe` and `unsubscribe` functions Enhancements: - Tables will now scroll when the rows exceed table height. Bugs: - Fixed a bug preventing async functions being used with horizontal line event. - Fixed a bug causing the legend to show duplicate lines if the line was created after the legend. - Fixed a bug causing the line hide icon to persist within the legend after deletion (#75) - Fixed a bug causing the search box to be unfocused when the chart is loaded.
5.5 KiB
5.5 KiB
Polygon.io
Polygon.io's market data API is directly integrated within lightweight-charts-python, and is easy to use within the library.
This class should be accessed from the `polygon` attribute, which is contained within all chart types.
`chart.polygon.<method>`
The `stock`, `option`, `index`, `forex`, and `crypto` methods of `chart.polygon` have common parameters:
* `timeframe`: The timeframe to be used (`'1min'`, `'5min'`, `'H'`, `'2D'`, `'5W'` etc.)
* `start_date`: The start date given in the format `YYYY-MM-DD`.
* `end_date`: The end date given in the same format. By default this is `'now'`, which uses the time now.
* `limit`: The maximum number of base aggregates to be queried to create the aggregate results.
* `live`: When set to `True`, a websocket connection will be used to update the chart or subchart in real-time.
* These methods will also return a boolean representing whether the request was successful.
The `websockets` library is required when using live data.
```{important}
When using live data and the standard `show` method, the `block` parameter __must__ be set to `True` in order for the data to congregate on the chart (`chart.show(block=True)`).
If `show_async` is used with live data, `block` can be either value.
```
For Example:
```python
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)
```
___
```{py:method} api_key(key: str)
Sets the API key for the chart. Subsequent `SubChart` objects will inherit the API key given to the parent chart.
```
___
```{py:method} stock(symbol: str, timeframe: str, start_date: str, end_date: str, limit: int, live: bool) -> bool
Requests and displays stock data pulled from Polygon.io.
`async_stock` can also be used.
```
___
```{py:method} option(symbol: str, timeframe: str, expiration: str, right: 'C' | 'P', strike: NUM, end_date: str, limit: int, live: bool) -> bool
Requests and displays option data pulled from Polygon.io.
A formatted option ticker (SPY251219C00650000) can also be given to the `symbol` parameter, allowing for `expiration`, `right`, and `strike` to be left blank.
`async_option` can also be used.
```
___
```{py:method} index(symbol: str, timeframe: str, start_date: str, end_date: str, limit: int, live: bool) -> bool
Requests and displays index data pulled from Polygon.io.
`async_index` can also be used.
```
___
```{py:method} forex(fiat_pair: str, timeframe: str, start_date: str, end_date: str, limit: int, live: bool) -> bool
Requests and displays a forex pair pulled from Polygon.io.
The two currencies should be separated by a '-' (`USD-CAD`, `GBP-JPY`, etc.).
`async_forex` can also be used.
```
___
```{py:method} crypto(crypto_pair: str, timeframe: str, start_date: str, end_date: str, limit: int, live: bool) -> bool
Requests and displays a crypto pair pulled from Polygon.io.
The two currencies should be separated by a '-' (`BTC-USD`, `ETH-BTC`, etc.).
`async_crypto` can also be used.
```
___
```{py:method} log(info: bool)
If `True`, informational log messages (connection, subscriptions etc.) will be displayed in the console.
Data errors will always be shown in the console.
```
The `PolygonChart` provides an easy and complete way to use the Polygon.io API within lightweight-charts-python.
This object requires the `websockets` library for live data.
All data is requested within the chart window through searching and selectors.
As well as the parameters from the [Chart](https://lightweight-charts-python.readthedocs.io/en/latest/charts.html#chart) object, PolygonChart also has the parameters:
* `api_key`: The user's Polygon.io API key.
* `num_bars`: The target number of bars to be displayed on the chart
* `limit`: The maximum number of base aggregates to be queried to create the aggregate results.
* `end_date`: The end date of the time window.
* `timeframe_options`: The selectors to be included within the timeframe selector.
* `security_options`: The selectors to be included within the security selector.
* `live`: If True, the chart will update in real-time.
___
For Example:
```python
from lightweight_charts import PolygonChart
if __name__ == '__main__':
chart = PolygonChart(
api_key='<API-KEY>',
num_bars=200,
limit=5000,
live=True
)
chart.show(block=True)
```
Module function which returns a formatted Dataframe of the requested aggregate data.
`ticker` should be prefixed for the appropriate security type (eg. `I:NDX`)
:async:
Subscribes the given callable to live data from polygon. emitting a dictionary (and any given arguments) to the function.
:async:
Unsubscribes the given function from live data.
The ticker will only be unsubscribed if there are no additional functions that are currently subscribed.