From cb08d06f6270e95fbd3f2b2f94870e0fff5189b5 Mon Sep 17 00:00:00 2001 From: CoprDistGit Date: Thu, 18 May 2023 04:35:55 +0000 Subject: automatic import of python-aio-kraken-ws --- .gitignore | 1 + python-aio-kraken-ws.spec | 253 ++++++++++++++++++++++++++++++++++++++++++++++ sources | 1 + 3 files changed, 255 insertions(+) create mode 100644 python-aio-kraken-ws.spec create mode 100644 sources diff --git a/.gitignore b/.gitignore index e69de29..6ba6e82 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1 @@ +/aio-kraken-ws-0.3.9.tar.gz diff --git a/python-aio-kraken-ws.spec b/python-aio-kraken-ws.spec new file mode 100644 index 0000000..41f4113 --- /dev/null +++ b/python-aio-kraken-ws.spec @@ -0,0 +1,253 @@ +%global _empty_manifest_terminate_build 0 +Name: python-aio-kraken-ws +Version: 0.3.9 +Release: 1 +Summary: Get ohlc from kraken web sockets. +License: MIT License +URL: https://gitlab.com/cdlr75/aio-kraken-ws +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/82/a8/35c0de20c11a1ab8f21c7c06e68ddcb4487b74535c7d7c168ac4fe6ad043/aio-kraken-ws-0.3.9.tar.gz +BuildArch: noarch + +Requires: python3-websockets +Requires: python3-asynctest +Requires: python3-pycodestyle +Requires: python3-pylint +Requires: python3-pytest +Requires: python3-pytest-cov +Requires: python3-pytest-xdist + +%description +A module to collect ohlc candles from Kraken using WebSockets that is asyncio friendly! Looking for automated trading tools? [Botcrypto](https://botcrypto.io) may interest you. +## Key features +- Subscribe to kraken data using a single WebSocket. +- Trigger a callback that is coroutine on each new closed candles from kraken. +- Easy subscribe/unsubscribe to datasets, i.e. [(pair, Unit Time)] ex: [('XBT/EUR', 1)]. +- Callback is regularly triggered at each end of the UT intervals, whatever is the number of data received by kraken. +## Getting started +#### Install +`pip install aio-kraken-ws` +#### Usage +```python +# check tests/learning/log_to_file.py for a complete example +async def callback(pair, interval, timestamp, o, h, l, c, v): + """ A coroutine handling new candles. + """ + with open("candles.txt", "a+") as file: + file.write(f"[{pair}:{interval}]({timestamp},{o},{h},{l},{c},{v})\n") +kraken_ws = await KrakenWs.create(callback) +# subscribe to some datasets +kraken_ws.subscribe([("XBT/EUR", 1), ("ETH/EUR", 5)]) +``` +The `callback` function is called for each dataset at the end of each dataset's unit time interval. +E.g. if subscription start at 4h42.05 to the dataset `("XBT/EUR", 1)`, then callback is triggered at 4h43.00, at 4h44.00, at 4h45.00, etc... For `("XBT/EUR", 60)`, it would be at 5h00.00, at 6h00.00, etc... It's possible to get at most 10ms delay between the exact UT interval ending and the actual datetime of the call. +If **no** new data were received from Kraken during an interval, the callback is triggered with the latest known close price and v=0, as it's described in the following example. +E.g. +```python +kraken_ws.subscribe([("XBT/EUR", 1)]) +# time.time() = 120 +await callback("XBT/EUR", 1, 60, 42.0, 57.0, 19.0, 24.0, 150.0) +# time.time() = 180 +await callback("XBT/EUR", 1, 120, 19.0, 24.0, 8.0, 10.0, 13.0) +# time.time() = 240 : no data received in 60s, i.e. no activity +await callback("XBT/EUR", 1, 180, 10.0, 10.0, 10.0, 10.0, 0.0) +``` +### Error management +- An exception raised by the `callback` will be logged and it wont stop the streams +- If kraken send an error message, an `ERROR` log is emitted with the kraken payload +- If kraken send 'Subscription ohlc interval not supported', the related dataset is automatically unsubscribed +#### Warning +The `callback` should takes less than a minute to process. If the `callback` takes more than a minutes, a *warning* is emitted and you may lose market data. +Kraken WebSocket server manage **20 subscriptions maximum** per connection. Above 20 subscriptions, you may not receive all desired data. +**Hopfully, aio-kraken-ws manage this limitation for you!** A new websocket connection is open every 20 subscriptions. +Moreover, after 24h a subscriptions seem to expire and no more market data is receive. To ensure we do not lose the stream of market data, **aio-kraken-ws** automatically reconnect and re-subscribe to the datasets every 5 minutes. +## Tests +You can find a working example of KrakenWs in `tests/learning/log_to_file.py`. +### Run tests locally +Clone the repo and install requirements +```sh +pip install -e .[test] +``` +Run the suite tests +```sh +# unit tests - no call to kraken - fast +pytest --cov=aio_kraken_ws --cov-report= -v tests/unit +# integration tests - actual kraken subscription - slow +pytest --cov=aio_kraken_ws --cov-append -v -n 8 tests/integration +``` +## Changelog +See https://cdlr75.gitlab.io/aio-kraken-ws/CHANGELOG.html + +%package -n python3-aio-kraken-ws +Summary: Get ohlc from kraken web sockets. +Provides: python-aio-kraken-ws +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-aio-kraken-ws +A module to collect ohlc candles from Kraken using WebSockets that is asyncio friendly! Looking for automated trading tools? [Botcrypto](https://botcrypto.io) may interest you. +## Key features +- Subscribe to kraken data using a single WebSocket. +- Trigger a callback that is coroutine on each new closed candles from kraken. +- Easy subscribe/unsubscribe to datasets, i.e. [(pair, Unit Time)] ex: [('XBT/EUR', 1)]. +- Callback is regularly triggered at each end of the UT intervals, whatever is the number of data received by kraken. +## Getting started +#### Install +`pip install aio-kraken-ws` +#### Usage +```python +# check tests/learning/log_to_file.py for a complete example +async def callback(pair, interval, timestamp, o, h, l, c, v): + """ A coroutine handling new candles. + """ + with open("candles.txt", "a+") as file: + file.write(f"[{pair}:{interval}]({timestamp},{o},{h},{l},{c},{v})\n") +kraken_ws = await KrakenWs.create(callback) +# subscribe to some datasets +kraken_ws.subscribe([("XBT/EUR", 1), ("ETH/EUR", 5)]) +``` +The `callback` function is called for each dataset at the end of each dataset's unit time interval. +E.g. if subscription start at 4h42.05 to the dataset `("XBT/EUR", 1)`, then callback is triggered at 4h43.00, at 4h44.00, at 4h45.00, etc... For `("XBT/EUR", 60)`, it would be at 5h00.00, at 6h00.00, etc... It's possible to get at most 10ms delay between the exact UT interval ending and the actual datetime of the call. +If **no** new data were received from Kraken during an interval, the callback is triggered with the latest known close price and v=0, as it's described in the following example. +E.g. +```python +kraken_ws.subscribe([("XBT/EUR", 1)]) +# time.time() = 120 +await callback("XBT/EUR", 1, 60, 42.0, 57.0, 19.0, 24.0, 150.0) +# time.time() = 180 +await callback("XBT/EUR", 1, 120, 19.0, 24.0, 8.0, 10.0, 13.0) +# time.time() = 240 : no data received in 60s, i.e. no activity +await callback("XBT/EUR", 1, 180, 10.0, 10.0, 10.0, 10.0, 0.0) +``` +### Error management +- An exception raised by the `callback` will be logged and it wont stop the streams +- If kraken send an error message, an `ERROR` log is emitted with the kraken payload +- If kraken send 'Subscription ohlc interval not supported', the related dataset is automatically unsubscribed +#### Warning +The `callback` should takes less than a minute to process. If the `callback` takes more than a minutes, a *warning* is emitted and you may lose market data. +Kraken WebSocket server manage **20 subscriptions maximum** per connection. Above 20 subscriptions, you may not receive all desired data. +**Hopfully, aio-kraken-ws manage this limitation for you!** A new websocket connection is open every 20 subscriptions. +Moreover, after 24h a subscriptions seem to expire and no more market data is receive. To ensure we do not lose the stream of market data, **aio-kraken-ws** automatically reconnect and re-subscribe to the datasets every 5 minutes. +## Tests +You can find a working example of KrakenWs in `tests/learning/log_to_file.py`. +### Run tests locally +Clone the repo and install requirements +```sh +pip install -e .[test] +``` +Run the suite tests +```sh +# unit tests - no call to kraken - fast +pytest --cov=aio_kraken_ws --cov-report= -v tests/unit +# integration tests - actual kraken subscription - slow +pytest --cov=aio_kraken_ws --cov-append -v -n 8 tests/integration +``` +## Changelog +See https://cdlr75.gitlab.io/aio-kraken-ws/CHANGELOG.html + +%package help +Summary: Development documents and examples for aio-kraken-ws +Provides: python3-aio-kraken-ws-doc +%description help +A module to collect ohlc candles from Kraken using WebSockets that is asyncio friendly! Looking for automated trading tools? [Botcrypto](https://botcrypto.io) may interest you. +## Key features +- Subscribe to kraken data using a single WebSocket. +- Trigger a callback that is coroutine on each new closed candles from kraken. +- Easy subscribe/unsubscribe to datasets, i.e. [(pair, Unit Time)] ex: [('XBT/EUR', 1)]. +- Callback is regularly triggered at each end of the UT intervals, whatever is the number of data received by kraken. +## Getting started +#### Install +`pip install aio-kraken-ws` +#### Usage +```python +# check tests/learning/log_to_file.py for a complete example +async def callback(pair, interval, timestamp, o, h, l, c, v): + """ A coroutine handling new candles. + """ + with open("candles.txt", "a+") as file: + file.write(f"[{pair}:{interval}]({timestamp},{o},{h},{l},{c},{v})\n") +kraken_ws = await KrakenWs.create(callback) +# subscribe to some datasets +kraken_ws.subscribe([("XBT/EUR", 1), ("ETH/EUR", 5)]) +``` +The `callback` function is called for each dataset at the end of each dataset's unit time interval. +E.g. if subscription start at 4h42.05 to the dataset `("XBT/EUR", 1)`, then callback is triggered at 4h43.00, at 4h44.00, at 4h45.00, etc... For `("XBT/EUR", 60)`, it would be at 5h00.00, at 6h00.00, etc... It's possible to get at most 10ms delay between the exact UT interval ending and the actual datetime of the call. +If **no** new data were received from Kraken during an interval, the callback is triggered with the latest known close price and v=0, as it's described in the following example. +E.g. +```python +kraken_ws.subscribe([("XBT/EUR", 1)]) +# time.time() = 120 +await callback("XBT/EUR", 1, 60, 42.0, 57.0, 19.0, 24.0, 150.0) +# time.time() = 180 +await callback("XBT/EUR", 1, 120, 19.0, 24.0, 8.0, 10.0, 13.0) +# time.time() = 240 : no data received in 60s, i.e. no activity +await callback("XBT/EUR", 1, 180, 10.0, 10.0, 10.0, 10.0, 0.0) +``` +### Error management +- An exception raised by the `callback` will be logged and it wont stop the streams +- If kraken send an error message, an `ERROR` log is emitted with the kraken payload +- If kraken send 'Subscription ohlc interval not supported', the related dataset is automatically unsubscribed +#### Warning +The `callback` should takes less than a minute to process. If the `callback` takes more than a minutes, a *warning* is emitted and you may lose market data. +Kraken WebSocket server manage **20 subscriptions maximum** per connection. Above 20 subscriptions, you may not receive all desired data. +**Hopfully, aio-kraken-ws manage this limitation for you!** A new websocket connection is open every 20 subscriptions. +Moreover, after 24h a subscriptions seem to expire and no more market data is receive. To ensure we do not lose the stream of market data, **aio-kraken-ws** automatically reconnect and re-subscribe to the datasets every 5 minutes. +## Tests +You can find a working example of KrakenWs in `tests/learning/log_to_file.py`. +### Run tests locally +Clone the repo and install requirements +```sh +pip install -e .[test] +``` +Run the suite tests +```sh +# unit tests - no call to kraken - fast +pytest --cov=aio_kraken_ws --cov-report= -v tests/unit +# integration tests - actual kraken subscription - slow +pytest --cov=aio_kraken_ws --cov-append -v -n 8 tests/integration +``` +## Changelog +See https://cdlr75.gitlab.io/aio-kraken-ws/CHANGELOG.html + +%prep +%autosetup -n aio-kraken-ws-0.3.9 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-aio-kraken-ws -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Thu May 18 2023 Python_Bot - 0.3.9-1 +- Package Spec generated diff --git a/sources b/sources new file mode 100644 index 0000000..2982a75 --- /dev/null +++ b/sources @@ -0,0 +1 @@ +cd9ae1b950ed356a5eb3faaee6ecefd0 aio-kraken-ws-0.3.9.tar.gz -- cgit v1.2.3