# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
from unicorn_binance_websocket_api.unicorn_binance_websocket_api_manager import BinanceWebSocketApiManager
from unicorn_fy.unicorn_fy import UnicornFy
import time
import logging
import os
logging.basicConfig(
level=logging.DEBUG,
filename=os.path.basename(__file__) + '.log',
format="{asctime} [{levelname:8}] {process} {thread} {module}: {message}",
style="{")
binance_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.com")
stream_id = binance_websocket_api_manager.create_stream(
['ticker'], ['btcusdt', 'bnbbtc', 'ethbtc'])
#binance_websocket_api_manager.create_stream(['miniTicker'], ['btcusdt', 'bnbbtc', 'ethbtc'])
#binance_websocket_api_manager.create_stream(['!miniTicker'], ['arr'])
#binance_websocket_api_manager.create_stream(['!ticker'], ['arr'])
time.sleep(10)
binance_websocket_api_manager.get_stream_subscriptions(stream_id)
time.sleep(5)
print(str(binance_websocket_api_manager.get_results_from_endpoints()))
time.sleep(5)
while True:
oldest_stream_data_from_stream_buffer = binance_websocket_api_manager.pop_stream_data_from_stream_buffer(
)
while True:
if binance_websocket_api_manager.is_manager_stopping():
exit(0)
oldest_stream_data_from_stream_buffer = binance_websocket_api_manager.pop_stream_data_from_stream_buffer()
if oldest_stream_data_from_stream_buffer is False:
time.sleep(0.01)
else:
print(oldest_stream_data_from_stream_buffer)
# configure api key and secret for binance.com
api_key = ""
api_secret = ""
# create instances of BinanceWebSocketApiManager
ubwa_com = BinanceWebSocketApiManager(exchange="binance.com")
# create the userData streams
user_stream_id = ubwa_com.create_stream('arr', '!userData', api_key=api_key, api_secret=api_secret)
# start a worker process to move the received stream_data from the stream_buffer to a print function
worker_thread = threading.Thread(target=print_stream_data_from_stream_buffer, args=(ubwa_com,))
worker_thread.start()
# configure api key and secret for binance.com Isolated Margin
api_key = ""
api_secret = ""
# create instances of BinanceWebSocketApiManager
ubwa_com_im = BinanceWebSocketApiManager(exchange="binance.com-isolated_margin")
def print_stream_data_from_stream_buffer(binance_websocket_api_manager):
time.sleep(30)
while True:
if binance_websocket_api_manager.is_manager_stopping():
exit(0)
oldest_stream_data_from_stream_buffer = binance_websocket_api_manager.pop_stream_data_from_stream_buffer(
)
if oldest_stream_data_from_stream_buffer is False:
time.sleep(0.01)
# create instance of BinanceWebSocketApiManager
#binance_websocket_api_manager = BinanceWebSocketApiManager(throw_exception_if_unrepairable=True)
binance_websocket_api_manager = BinanceWebSocketApiManager(
throw_exception_if_unrepairable=False)
print("starting monitoring api!")
binance_websocket_api_manager.start_monitoring_api()
try:
binance_rest_client = Client(binance_api_key, binance_api_secret)
binance_websocket_api_manager = BinanceWebSocketApiManager()
except requests.exceptions.ConnectionError:
print("No internet connection?")
sys.exit(1)
# start a worker process to move the received stream_data from the stream_buffer to a print function
worker_thread = threading.Thread(target=print_stream_data_from_stream_buffer,
args=(binance_websocket_api_manager, ))
worker_thread.start()
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
from unicorn_binance_websocket_api.unicorn_binance_websocket_api_manager import BinanceWebSocketApiManager
# create instance of BinanceWebSocketApiManager
binance_websocket_api_manager = BinanceWebSocketApiManager()
# get version of the used UNICORN Binance WebSocket API
if binance_websocket_api_manager.is_update_availabe():
print(
"Please upgrade to " +
binance_websocket_api_manager.get_latest_version() + ", you are on",
binance_websocket_api_manager.get_version())
latest_release_info = binance_websocket_api_manager.get_latest_release_info(
)
if latest_release_info:
print(
"Please download the latest release or run `pip install unicorn-binance-websocket-api --upgrade`: "
)
print("\ttar: " + latest_release_info["tarball_url"])
def test_rest_jex_com_testnet(self):
binance_websocket_api_manager = BinanceWebSocketApiManager(
exchange="jex.com")
BinanceWebSocketApiRestclient(binance_websocket_api_manager)
binance_websocket_api_manager.stop_manager_with_all_streams()
def test_live_run(self):
binance_websocket_api_manager = BinanceWebSocketApiManager(
enable_stream_signal_buffer=True)
binance_websocket_api_manager.get_active_stream_list()
binance_websocket_api_manager.get_limit_of_subscriptions_per_stream()
binance_websocket_api_manager.get_stream_list()
markets = [
'xrpbearbusd', 'zeceth', 'cndbtc', 'dashbtc', 'atompax', 'perlbtc',
'ardreth', 'zecbnb', 'bchabctusd', 'usdsbusdt', 'winbnb', 'xzcxrp',
'bchusdc', 'wavesbnb', 'kavausdt', 'btsusdt', 'chzbnb', 'tusdbnb',
'xtzbusd', 'bcptusdc', 'dogebnb', 'eosbearusdt', 'ambbnb',
'wrxbnb', 'poabtc', 'wanbtc', 'ardrbtc', 'icnbtc', 'tusdusdt',
'atombusd', 'nxseth', 'bnbusdt', 'trxxrp', 'erdpax', 'erdbtc',
'icxbusd', 'nulsbtc', 'hotusdt', 'wavespax', 'zilbnb', 'arnbtc',
'nulsusdt', 'wintrx', 'npxsbtc', 'busdtry', 'qtumbnb', 'eosbtc',
'xlmpax', 'tomobnb', 'eosbnb', 'engbtc', 'linketh', 'xrpbtc',
'fetbtc', 'stratusdt', 'navbnb', 'bcneth', 'yoyobtc', 'nanobnb',
'saltbtc', 'tfuelusdc', 'skybnb', 'fuelbtc', 'bnbusdc', 'inseth',
'btcpax', 'batbtc', 'rlceth', 'arketh', 'ltcpax', 'ltcbusd',
'duskbtc', 'mftusdt', 'bntusdt', 'mdabtc', 'enjbtc', 'poabnb',
'nanobusd', 'paxtusd', 'hotbtc', 'bcdbtc', 'beambnb', 'trxeth',
'omgbnb', 'cdtbtc', 'eosusdc', 'dashbusd', 'cocosbtc', 'dasheth',
'xrptusd', 'atomtusd', 'rcneth', 'rpxeth', 'xlmusdc', 'aionbusd',
'nxsbtc', 'chateth', 'repbtc', 'tctusdt', 'linkusdt', 'nasbtc',
'usdsusdc', 'xvgbtc', 'elfeth', 'ctxcbtc', 'cmteth', 'gnteth',
'usdspax', 'zilbtc', 'batpax', 'stratbtc', 'xzcbtc', 'iotausdt',
'etcbnb', 'ankrusdt', 'xlmeth', 'loombtc', 'erdusdc', 'rdnbnb',
'icneth', 'vetbtc', 'cvcusdt', 'ftmpax', 'ethbullusdt', 'edoeth',
'steemeth', 'gobnb', 'hsrbtc', 'ambbtc', 'bchabcbtc', 'dntbtc',
'btctusd', 'denteth', 'snglsbtc', 'eosbullusdt', 'xlmtusd',
'tnteth', 'sysbnb', 'renusdt', 'zrxusdt', 'xlmbtc', 'stormbtc',
'ncashbnb', 'omgusdt', 'troyusdt', 'venbtc', 'modbtc', 'dogepax',
'ontusdc', 'eurbusd', 'tctbnb', 'gxsbtc', 'celrbnb', 'adausdt',
'beambtc', 'elfbtc', 'celrbtc', 'rvnusdt', 'poaeth', 'wavesusdc',
'trxbnb', 'trxusdc', 'ethbearusdt', 'ethpax', 'bateth', 'kavabtc',
'paxbtc', 'trigbnb', 'btcusdc', 'oneusdc', 'xrptry', 'stxusdt',
'strateth', 'lendeth', 'neousdc', 'mithusdt', 'btcngn', 'blzeth',
'evxeth', 'dnteth', 'grsbtc', 'arneth', 'iotabnb', 'waneth',
'xtzbnb', 'subeth', 'btsbtc', 'cvceth', 'ethusdc', 'etctusd',
'cloakbtc', 'grseth', 'eospax', 'cdteth', 'bchusdt', 'lskusdt',
'enjbusd', 'drepbtc', 'manaeth', 'tomousdt', 'algobnb', 'wtceth',
'linkpax', 'batbnb', 'sceth', 'rvnbusd', 'cvcbnb', 'manabtc',
'gasbtc', 'stxbtc', 'cloaketh', 'neotusd', 'lrceth', 'thetabtc',
'dogeusdt', 'aionbnb', 'viabtc', 'keyeth', 'nanoeth', 'ncasheth',
'bgbpusdc', 'ltobnb', 'snmeth', 'adabtc', 'btseth', 'qtumbusd',
'wtcbnb', 'dcrbtc', 'fttbnb', 'paxbnb', 'insbtc', 'gntbnb',
'etheur', 'dashusdt', 'rcnbtc', 'btcusdt', 'wanusdt', 'powrbnb',
'xmrbnb', 'trigeth', 'xzceth', 'bchbtc', 'qspbnb', 'scbnb',
'mcoeth', 'powrbtc', 'algotusd', 'ankrbtc', 'tusdeth', 'keybtc',
'usdcusdt', 'ftmusdc', 'atombnb', 'zenbtc', 'dockbtc', 'neobtc',
'phbbnb', 'bnbpax', 'brdbnb', 'trxusdt', 'trxbusd', 'mtlbtc',
'ftmtusd', 'perlusdc', 'mithbnb', 'eosbullbusd', 'reqeth',
'bccbnb', 'veneth', 'loombnb', 'trxpax', 'usdcpax', 'stormusdt',
'ognbtc', 'gvtbtc', 'iotaeth', 'naseth', 'drepusdt', 'gvteth',
'wrxusdt', 'bchabcpax', 'ongbtc', 'usdcbnb', 'dgdeth', 'salteth',
'mtleth', 'bcnbnb', 'neblbnb', 'wanbnb', 'ontusdt', 'npxsusdt',
'mftbtc', 'eosbearbusd', 'bntbtc', 'gtoeth', 'modeth', 'etcusdc',
'veteth', 'bcptpax', 'atomusdc', 'duskpax', 'kavabnb', 'lunbtc',
'adxbtc', 'bnteth', 'funbtc', 'knceth', 'dogebtc', 'bchsvpax',
'bcpttusd', 'osteth', 'oaxeth', 'wabibtc', 'appcbtc', 'qkcbtc',
'nanousdt', 'wingsbtc', 'hbarusdt', 'eurusdt', 'waveseth',
'asteth', 'linkbusd', 'btttusd', 'zecusdc', 'bnbusds', 'linkbtc',
'venusdt', 'hotbnb', 'usdtrub', 'tctbtc', 'ankrpax', 'btctry',
'adabnb', 'polybtc', 'bcceth', 'enjeth', 'bnbbusd', 'repbnb',
'bullusdt', 'vitebtc', 'btgbtc', 'renbtc', 'thetausdt', 'troybtc',
'dentbtc', 'ostbtc', 'nxsbnb', 'mithbtc', 'xmrbtc', 'tomobtc',
'nulseth', 'phbbtc', 'duskbnb', 'yoyoeth', 'ontbusd', 'btgeth',
'etcusdt', 'atomusdt', 'hcbtc', 'brdbtc', 'fttbtc', 'celrusdt',
'lskbnb', 'phbpax', 'xtzbtc', 'batusdt', 'viteusdt', 'trxbtc',
'bchtusd', 'xtzusdt', 'ftmbtc', 'enjbnb', 'arkbtc', 'wavesusdt',
'ftmusdt', 'neobusd', 'stormbnb', 'luneth', 'gntbtc', 'gtousdt',
'chzusdt', 'sntbtc', 'bandbnb', 'hoteth', 'wingseth', 'mcobtc',
'docketh', 'drepbnb', 'eosusdt', 'eostusd', 'npxseth', 'thetaeth',
'iotxbtc', 'phxbnb', 'enjusdt', 'tfuelbnb', 'mcobnb', 'ontpax',
'dcrbnb', 'batusdc', 'snglseth', 'qlcbtc', 'qspeth', 'cndeth',
'appcbnb', 'wprbtc', 'sysbtc', 'iostusdt', 'btceur', 'mtlusdt',
'ethrub', 'tfuelpax', 'maticusdt', 'ftmbnb', 'xrpbusd', 'iotxusdt',
'tusdbtusd', 'trigbtc', 'atombtc', 'bchpax', 'eosbusd', 'zileth',
'gtotusd', 'xrpbullusdt', 'onetusd', 'algobtc', 'bchsvusdt',
'gtopax', 'etceth', 'vibebtc', 'bttusdt', 'repeth', 'iostbnb',
'usdttry', 'btsbnb', 'ankrbnb', 'dltbnb', 'snteth', 'linktusd',
'nknusdt', 'rpxbtc', 'rdneth', 'cocosusdt', 'etcbusd', 'btttrx',
'bandbtc', 'steembnb', 'zecpax', 'viabnb', 'cosbnb', 'mtheth',
'xrpusdc', 'xemeth', 'pivxbnb', 'phxbtc', 'zilusdt', 'poeeth',
'bnbeur', 'bandusdt', 'vetbnb', 'lendbtc', 'xlmbnb', 'duskusdt',
'mfteth', 'funusdt', 'adabusd', 'perlbnb', 'btcbusd', 'ltobtc',
'nasbnb', 'algousdt', 'zeneth', 'bchsvusdc', 'mcousdt', 'venbnb',
'hceth', 'fetusdt', 'edobtc', 'mftbnb', 'cosusdt', 'arpausdt',
'xmrusdt', 'ctxcusdt', 'bqxbtc', 'npxsusdc', 'icxbnb', 'bchbnb',
'phbusdc', 'tomousdc', 'nulsbnb', 'rcnbnb', 'arpabnb', 'qtumbtc',
'keyusdt', 'agibtc', 'mblbtc', 'eoseth', 'tusdbtc', 'aioneth',
'storjbtc', 'lsketh', 'bchsvbtc', 'bntbusd', 'ncashbtc', 'mblbnb',
'polybnb', 'aebnb', 'ltceth', 'dogeusdc', 'wpreth', 'syseth',
'bcnbtc', 'ognusdt', 'nanobtc', 'astbtc', 'zrxeth', 'adxeth',
'gxseth', 'ethbearbusd', 'onepax', 'scbtc', 'icxbtc', 'ontbnb',
'qlceth', 'btsbusd', 'rlcbtc', 'chatbtc', 'wabibnb', 'renbnb',
'xrpbullbusd', 'wavesbtc', 'funeth', 'rlcbnb', 'phxeth', 'winbtc',
'storjeth', 'wavesbusd', 'iostbtc', 'icxeth', 'adatusd', 'nknbnb',
'btcrub', 'pivxbtc', 'perlusdt', 'bullbusd', 'bttusdc', 'bcptbtc',
'aebtc', 'ethusdt', 'ltousdt', 'subbtc', 'thetabnb', 'blzbtc',
'tfuelusdt', 'evxbtc', 'hbarbtc', 'ambeth', 'winusdt', 'qtumeth',
'dgdbtc', 'adaeth', 'busdusdt', 'xrpbnb', 'adapax', 'usdsbusds',
'cocosbnb', 'navbtc', 'rvnbtc', 'tnbbtc', 'bnbbtc', 'neopax',
'bearusdt', 'usdstusd', 'snmbtc', 'rvnbnb', 'gtobnb', 'phbtusd',
'hcusdt', 'btcusds', 'reqbtc', 'ognbnb', 'lrcbtc', 'xrpeth',
'loometh', 'zectusd', 'vibeeth', 'gobtc', 'bnbtry', 'bcdeth',
'qkceth', 'neoeth', 'paxusdt', 'bchsvtusd', 'fetbnb', 'yoyobnb',
'xlmbusd', 'skyeth', 'paxeth', 'ltcbtc', 'xvgeth', 'tnbeth',
'stratbusd', 'agieth', 'xlmusdt', 'lskbtc', 'bearbusd', 'hsreth',
'ctxcbnb', 'oaxbtc', 'qspbtc', 'iotxeth', 'qlcbnb', 'algousdc',
'etcpax', 'fueleth', 'aionusdt', 'xmreth', 'maticbtc', 'dashbnb',
'oneusdt', 'brdeth', 'viaeth', 'omgeth', 'ankrtusd', 'usdsusdt',
'ethtusd', 'wavestusd', 'iosteth', 'cmtbnb', 'ostbnb', 'ltcusdt',
'ethtry', 'zrxbtc', 'bchabcusdt', 'onebnb', 'beamusdt', 'nebleth',
'bcptbnb', 'adxbnb', 'ontbtc', 'bttbnb', 'dockusdt', 'bccbtc',
'omgbtc', 'algopax', 'neousdt', 'xrprub', 'busdngn', 'appceth',
'dentusdt', 'xzcbnb', 'tfueltusd', 'xembnb', 'arpabtc', 'ankrusdc',
'adausdc', 'kmdeth', 'troybnb', 'bnbeth', 'ltcusdc', 'databtc',
'blzbnb', 'naveth', 'btcbbtc', 'battusd', 'bnbngn', 'bchbusd',
'busdrub', 'ltctusd', 'vetbusd', 'ongbnb', 'fttusdt', 'bccusdt',
'ongusdt', 'engeth', 'usdctusd', 'etcbtc', 'gtousdc', 'mdaeth',
'vitebnb', 'erdusdt', 'dltbtc', 'bnbtusd', 'wtcbtc', 'xrpusdt',
'xrpeur', 'agibnb', 'trxtusd', 'ethbullbusd', 'iotabtc', 'xembtc',
'bchabcusdc', 'duskusdc', 'xrppax', 'mblusdt', 'kmdbtc', 'neblbtc',
'maticbnb', 'bnbrub', 'bcpteth', 'bttbtc', 'stxbnb', 'dlteth',
'onteth', 'vetusdt', 'ppteth', 'ethbtc', 'onebtc', 'ethbusd',
'zecbtc', 'erdbnb', 'xrpbearusdt', 'stratbnb', 'cmtbtc', 'cvcbtc',
'kncbtc', 'rpxbnb', 'zenbnb', 'cndbnb', 'ardrbnb', 'bchabcbusd',
'ltcbnb', 'pivxeth', 'skybtc', 'tntbtc', 'poebtc', 'steembtc',
'icxusdt', 'tfuelbtc', 'chzbtc', 'vibeth', 'winusdc', 'gtobtc',
'linkusdc', 'batbusd', 'rdnbtc', 'dataeth', 'bttpax', 'zrxbnb',
'vibbtc', 'neobnb', 'cosbtc', 'powreth', 'rlcusdt', 'hbarbnb',
'wabieth', 'bqxeth', 'aionbtc', 'aeeth', 'mthbtc', 'wrxbtc',
'pptbtc', 'nknbtc', 'zecusdt', 'stormeth', 'qtumusdt'
]
channels = [
'kline_1m', 'kline_5m', 'kline_15m', 'kline_30m', 'kline_1h',
'kline_12h', 'kline_1w', 'trade', 'miniTicker', 'depth20'
]
binance_websocket_api_manager.create_stream(False,
False,
stream_label="error")
for channel in channels:
stream_id1 = binance_websocket_api_manager.create_stream(
channel, markets, output="UnicornFy")
time.sleep(5)
binance_websocket_api_manager.set_restart_request(stream_id1)
time.sleep(10)
binance_websocket_api_manager.set_restart_request(stream_id1)
restserver = BinanceWebSocketApiRestServer(
binance_websocket_api_manager)
restserver.get("icinga")
restserver.get("invalid")
markets = [
'xrpbearbusd', 'zeceth', 'cndbtc', 'dashbtc', 'atompax', 'perlbtc',
'ardreth', 'zecbnb', 'erdbnb', 'xrpbearusdt', 'stratbnb', 'cmtbtc',
'cvcbtc', 'kncbtc', 'rpxbnb', 'zenbnb', 'cndbnb', 'wrxbtc',
'pptbtc', 'nknbtc', 'zecusdt', 'stormeth', 'qtumusdt'
]
for channel in channels:
stream_id2 = binance_websocket_api_manager.create_stream(
channel,
markets,
stream_buffer_name=channel,
ping_interval=10,
ping_timeout=10,
close_timeout=5)
stream_id3 = binance_websocket_api_manager.create_stream(
channel, markets, stream_buffer_name=True)
time.sleep(10)
binance_websocket_api_manager.stop_stream_as_crash(stream_id3)
binance_websocket_api_manager.create_websocket_uri(
False, False, stream_id1)
binance_websocket_api_manager.unsubscribe_from_stream(stream_id2,
markets="erdbnb")
binance_websocket_api_manager.unsubscribe_from_stream(stream_id2,
channels="trade")
binance_websocket_api_manager.pop_stream_data_from_stream_buffer()
binance_websocket_api_manager.pop_stream_data_from_stream_buffer()
binance_websocket_api_manager.pop_stream_data_from_stream_buffer()
binance_websocket_api_manager.pop_stream_data_from_stream_buffer(
stream_buffer_name="invalid")
stream_id_1_1 = binance_websocket_api_manager.replace_stream(
stream_id1, 'trade', 'kncbtc', "name")
binance_websocket_api_manager.replace_stream(stream_id_1_1,
'trade',
'kncbtc',
"name",
new_ping_interval=10,
new_ping_timeout=10,
new_close_timeout=5)
binance_websocket_api_manager.get_results_from_endpoints()
binance_websocket_api_manager.get_binance_api_status()
binance_websocket_api_manager.get_start_time()
binance_websocket_api_manager.get_stream_label(stream_id1)
binance_websocket_api_manager.get_stream_label(False)
binance_websocket_api_manager.get_keep_max_received_last_second_entries(
)
request_id = binance_websocket_api_manager.get_stream_subscriptions(
stream_id2)
binance_websocket_api_manager.get_result_by_request_id(request_id)
binance_websocket_api_manager.get_reconnects()
binance_websocket_api_manager.get_errors_from_endpoints()
binance_websocket_api_manager.get_monitoring_status_plain()
binance_websocket_api_manager.get_ringbuffer_error_max_size()
binance_websocket_api_manager.get_ringbuffer_result_max_size()
binance_websocket_api_manager.set_ringbuffer_error_max_size(200)
binance_websocket_api_manager.set_ringbuffer_result_max_size(300)
binance_websocket_api_manager.set_stream_label(stream_id2, "blub")
binance_websocket_api_manager._add_stream_to_stream_list(
uuid.uuid4(), 'trade', 'btceth')
binance_websocket_api_manager._restart_stream((stream_id1))
binance_websocket_api_manager.delete_stream_from_stream_list(
stream_id1)
binance_websocket_api_manager.delete_listen_key_by_stream_id(
stream_id1)
binance_websocket_api_manager.is_update_availabe_unicorn_fy()
binance_websocket_api_manager.get_version_unicorn_fy()
binance_websocket_api_manager.create_payload(stream_id2,
"invalid",
channels="trade")
time.sleep(10)
binance_websocket_api_manager.get_result_by_request_id(request_id)
binance_websocket_api_manager.get_result_by_request_id()
binance_websocket_api_manager.set_keep_max_received_last_second_entries(
30)
binance_websocket_api_manager.stop_stream_as_crash(stream_id2)
binance_websocket_api_manager.stop_stream(stream_id2)
binance_websocket_api_manager.add_to_ringbuffer_error("test")
binance_websocket_api_manager.add_to_ringbuffer_result("test")
binance_websocket_api_manager.get_number_of_free_subscription_slots(
stream_id2)
binance_websocket_api_manager.get_most_receives_per_second()
binance_websocket_api_manager.get_number_of_streams_in_stream_list()
binance_websocket_api_manager.is_update_availabe_check_command()
binance_websocket_api_manager.wait_till_stream_has_stopped(stream_id2)
binance_websocket_api_manager.print_stream_info(stream_id2)
binance_websocket_api_manager.print_summary()
binance_websocket_api_manager.print_summary_to_png(".", 12.5)
binance_websocket_api_manager.get_latest_release_info()
binance_websocket_api_manager.get_latest_release_info_check_command()
binance_websocket_api_manager.set_private_dex_config(
"bnb1v566f3avl2ud5z0jepazsrguzkj367snlx4jm6")
binance_websocket_api_manager.get_version()
binance_websocket_api_manager.help()
binance_websocket_api_manager.get_current_receiving_speed_global()
binance_websocket_api_manager.wait_till_stream_has_started(stream_id2)
binance_websocket_api_manager.remove_ansi_escape_codes("test text")
binance_websocket_api_manager.pop_stream_signal_from_stream_signal_buffer(
)
# test to many subscriptions
import unicorn_binance_rest_api
binance_api_key = ""
binance_api_secret = ""
binance_rest_client = unicorn_binance_rest_api.BinanceRestApiManager(
binance_api_key, binance_api_secret)
markets = []
data = binance_rest_client.get_all_tickers()
for item in data:
markets.append(item['symbol'])
binance_websocket_api_manager.create_stream("trade",
markets,
stream_label="to much!")
time.sleep(10)
binance_websocket_api_manager.stop_manager_with_all_streams()
def setUp(self):
self.binance_je_api_key = BINANCE_JE_API_KEY
self.binance_je_api_secret = BINANCE_JE_API_SECRET
self.binance_je_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.je")
def test_rest_binance_com_isolated_margin_testnet(self):
binance_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.com-isolated_margin-testnet")
BinanceWebSocketApiRestclient(binance_websocket_api_manager)
binance_websocket_api_manager.stop_manager_with_all_streams()
if oldest_stream_data_from_stream_buffer is not False:
pass
else:
time.sleep(0.01)
def print_stream_to_png(manager):
while True:
manager.print_summary_to_png("/var/www/html/", hight_per_row=13.5)
time.sleep(10)
try:
binance_rest_client = unicorn_binance_rest_api.BinanceRestApiManager(
binance_api_key, binance_api_secret)
ws_manager = BinanceWebSocketApiManager()
except requests.exceptions.ConnectionError:
print("No internet connection?")
sys.exit(1)
worker_thread = threading.Thread(target=print_stream_data_from_stream_buffer,
args=(ws_manager, ))
worker_thread.start()
export_thread = threading.Thread(target=print_stream_to_png,
args=(ws_manager, ))
export_thread.start()
markets = []
data = binance_rest_client.get_all_tickers()
for item in data:
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
from unicorn_binance_websocket_api.unicorn_binance_websocket_api_manager import BinanceWebSocketApiManager
import logging
import os
import time
import threading
# https://docs.python.org/3/library/logging.html#logging-levels
logging.basicConfig(level=logging.INFO,
filename=os.path.basename(__file__) + '.log',
format="{asctime} [{levelname:8}] {process} {thread} {module}: {message}",
style="{")
binance_websocket_api_manager = BinanceWebSocketApiManager(enable_stream_signal_buffer=True)
def print_stream_signals(binance_websocket_api_manager):
while True:
if binance_websocket_api_manager.is_manager_stopping():
exit(0)
stream_signal = binance_websocket_api_manager.pop_stream_signal_from_stream_signal_buffer()
if stream_signal is False:
time.sleep(0.01)
else:
print(stream_signal)
# start a worker process to process to move the received stream_data from the stream_buffer to a print function
worker_thread = threading.Thread(target=print_stream_signals, args=(binance_websocket_api_manager,))
worker_thread.start()
# IN THE SOFTWARE.
from unicorn_binance_websocket_api.unicorn_binance_websocket_api_manager import BinanceWebSocketApiManager
import logging
import time
import os
# https://docs.python.org/3/library/logging.html#logging-levels
logging.basicConfig(
level=logging.ERROR,
filename=os.path.basename(__file__) + '.log',
format="{asctime} [{levelname:8}] {process} {thread} {module}: {message}",
style="{")
# create instance of BinanceWebSocketApiManager
binance_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.com", output_default="UnicornFy")
markets = {
'bnbbtc', 'ethbtc', 'btcusdt', 'bchabcusdt', 'xrpusdt', 'rvnbtc',
'ltcusdt', 'adausdt', 'eosusdt', 'neousdt', 'bnbusdt', 'adabtc', 'ethusdt',
'trxbtc', 'bchabcbtc', 'ltcbtc', 'xrpbtc', 'ontbtc', 'bttusdt', 'eosbtc',
'xlmbtc', 'bttbtc', 'tusdusdt', 'xlmusdt', 'qkcbtc', 'zrxbtc', 'neobtc',
'adaeth', 'icxusdt', 'btctusd', 'icxbtc', 'btcusdc', 'wanbtc', 'zecbtc',
'wtcbtc', 'batbtc', 'adabnb', 'etcusdt', 'qtumusdt', 'xmrbtc', 'trxeth',
'adatusd', 'trxxrp', 'trxbnb', 'dashbtc', 'rvnbnb', 'bchabctusd', 'etcbtc',
'bnbeth', 'ethpax', 'nanobtc', 'xembtc', 'xrpbnb', 'bchabcpax', 'xrpeth',
'bttbnb', 'ltcbnb', 'agibtc', 'zrxusdt', 'xlmbnb', 'ltceth', 'eoseth',
'ltctusd', 'polybnb', 'scbtc', 'steembtc', 'trxtusd', 'npxseth', 'kmdbtc',
'polybtc', 'gasbtc', 'engbtc', 'zileth', 'xlmeth', 'eosbnb', 'xrppax',
'lskbtc', 'npxsbtc', 'xmrusdt', 'ltcpax', 'ethtusd', 'batusdt', 'mcobtc',
'neoeth', 'bntbtc', 'eostusd', 'lrcbtc', 'funbtc', 'zecusdt', 'bnbpax',
def run(self):
self.binance_websocket_api_manager = BinanceWebSocketApiManager(exchange="binance.com-futures",
output_default="UnicornFy")
self.binance_websocket_api_manager.create_stream(['kline_1m', 'kline_1h', 'depth5'],
[f'{self.symbol}usdt'],
stream_label="UnicornFy",
output="UnicornFy")
while self.bot_ping:
if self.status:
self.status = False
self.binance_websocket_api_manager.create_stream(['kline_1m', 'kline_1h', 'depth5'],
[f'{self.symbol}usdt'],
stream_label="UnicornFy",
output="UnicornFy")
print(f"PARSER RESTART at {datetime.now().strftime('%H:%M:%S')}")
else:
try:
if self.binance_websocket_api_manager.is_manager_stopping():
exit(0)
self.status = True
stream_buffer = self.binance_websocket_api_manager.pop_stream_data_from_stream_buffer()
if stream_buffer:
print(stream_buffer)
try:
if stream_buffer['event_type'] == "bookTicker":
print(stream_buffer)
self.my_ask = float(stream_buffer['asks'][0][0])
self.my_bid = float(stream_buffer['bids'][0][0])
# print("ASK :", self.my_ask)
else:
if stream_buffer['event_type'] == "kline":
if stream_buffer['kline']['interval'] == "1m":
if stream_buffer['event_time'] >= stream_buffer['kline']['kline_close_time']:
new_row = [stream_buffer['kline']['kline_start_time'],
stream_buffer['kline']['open_price'],
stream_buffer['kline']['high_price'],
stream_buffer['kline']['low_price'],
stream_buffer['kline']['close_price'],
stream_buffer['kline']['base_volume'],
stream_buffer['kline']['kline_close_time'],
None, None, None, None, None]
self.main_data.append(new_row)
del self.main_data[0]
elif stream_buffer['kline']['interval'] == "1h":
if stream_buffer['event_time'] >= stream_buffer['kline']['kline_close_time']:
new_row = [stream_buffer['kline']['kline_start_time'],
stream_buffer['kline']['open_price'],
stream_buffer['kline']['high_price'],
stream_buffer['kline']['low_price'],
stream_buffer['kline']['close_price'],
stream_buffer['kline']['base_volume'],
stream_buffer['kline']['kline_close_time'],
None, None, None, None, None]
self.main_data_hour.append(new_row)
del self.main_data_hour[0]
time.sleep(0.2)
except KeyError:
print(f"Exception :\n {stream_buffer}")
time.sleep(0.5)
else:
time.sleep(0.01)
except Exception as exc:
self.status = True
traceback.print_exc()
time.sleep(30)
telega_api_key = new_keys['telega']['key']
telega_api_secret = new_keys['telega']['secret']
api_key = new_keys['bin']['key']
api_secret = new_keys['bin']['secret']
#
#
# new_data = SsrmBot("trx", float(20), api_key, api_secret)
#
# new_data.run()
###########################
bot_ping = True
binance_websocket_api_manager = BinanceWebSocketApiManager(exchange="binance.com-futures",
output_default="dict")
# binance_websocket_api_manager.create_stream(['kline_1m'],
# ['trxusdt'],
# stream_label="UnicornFy",
# output="UnicornFy")
#
# binance_websocket_api_manager.create_stream(['trade'],
# ['trxusdt'],
# output="UnicornFy")
binance_websocket_api_manager.create_stream('arr', '!userData',
api_key=api_key, api_secret=api_secret,
output="dict"
)
while bot_ping:
def setUp(self):
self.binance_org_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.org")
# configure api key and secret for binance.com
binance_com_api_key = ""
binance_com_api_secret = ""
# configure api key and secret for binance.je
binance_je_api_key = ""
binance_je_api_secret = ""
# configure api key and secret for binance.us
binance_us_api_key = ""
binance_us_api_secret = ""
# create instances of BinanceWebSocketApiManager
binance_com_websocket_api_manager = BinanceWebSocketApiManager(exchange="binance.com")
binance_je_websocket_api_manager = BinanceWebSocketApiManager(exchange="binance.je")
binance_us_websocket_api_manager = BinanceWebSocketApiManager(exchange="binance.us")
# set api key and secret in api manager
binance_com_websocket_api_manager.set_private_api_config(binance_com_api_key, binance_com_api_secret)
binance_je_websocket_api_manager.set_private_api_config(binance_je_api_key, binance_je_api_secret)
binance_us_websocket_api_manager.set_private_api_config(binance_us_api_key, binance_us_api_secret)
# create the userData streams
binance_com_user_data_stream_id = binance_com_websocket_api_manager.create_stream('arr', '!userData')
binance_je_user_data_stream_id = binance_je_websocket_api_manager.create_stream('arr', '!userData')
binance_us_user_data_stream_id = binance_us_websocket_api_manager.create_stream('arr', '!userData')
# start a worker process to move the received stream_data from the stream_buffer to a print function
worker_thread = threading.Thread(target=print_stream_data_from_stream_buffer, args=(binance_com_websocket_api_manager,))
def setUp(self):
self.binance_com_api_key = BINANCE_COM_API_KEY
self.binance_com_api_secret = BINANCE_COM_API_SECRET
self.binance_com_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.com", disable_colorama=True)
from unicorn_binance_websocket_api.unicorn_binance_websocket_api_manager import BinanceWebSocketApiManager
import time
api_key = ""
api_secret = ""
def book_ticker(msg):
print("book_ticker: " + str(msg))
def order_status(msg):
print("order_status: " + str(msg))
bwsm = BinanceWebSocketApiManager()
book_ticker_id = bwsm.create_stream("bookTicker", 'bnbbusd', stream_buffer_name=True)
user_stream_id = bwsm.create_stream('arr', '!userData', api_key=api_key, api_secret=api_secret, stream_buffer_name=True)
while True:
msg = bwsm.pop_stream_data_from_stream_buffer(book_ticker_id)
if msg:
book_ticker(msg)
msg = bwsm.pop_stream_data_from_stream_buffer(user_stream_id)
if msg:
order_status(msg)
time.sleep(0.01)
def test_rest_binance_com_coin_futures(self):
binance_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.com-coin-futures")
BinanceWebSocketApiRestclient(binance_websocket_api_manager)
binance_websocket_api_manager.stop_manager_with_all_streams()
import asyncio
import concurrent.futures
import logging
import os
import sys
import time
from unicorn_binance_websocket_api.unicorn_binance_websocket_api_manager import \
BinanceWebSocketApiManager
from nifi_websocket import NifiWebSocketClient
logging.basicConfig(level=logging.INFO)
BINANCE_WS_API_MANAGERS = {
'futures': BinanceWebSocketApiManager(exchange="binance.com-futures")
}
class StreamsParameters:
PRIVATE = [(
BINANCE_WS_API_MANAGERS['futures'],
'arr',
'!userData',
'binance_futures_user_data',
)]
PUBLIC = [(
BINANCE_WS_API_MANAGERS['futures'],
'trade',
'btcusdt',
'binance_futures_trade_btcusdt',
def test_invalid_exchange(self):
from unicorn_binance_websocket_api.unicorn_binance_websocket_api_exceptions import UnknownExchange
try:
BinanceWebSocketApiManager(exchange="invalid-exchange.com")
except UnknownExchange:
pass
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
import setuptools
from unicorn_binance_websocket_api.unicorn_binance_websocket_api_manager import BinanceWebSocketApiManager
ubwa = BinanceWebSocketApiManager()
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name='unicorn-binance-websocket-api',
version=str(ubwa.get_version()),
author="Oliver Zehentleitner",
url="https://github.com/oliver-zehentleitner/unicorn-binance-websocket-api",
description="An unofficial Python API to use the Binance Websocket API`s (com+testnet, com-margin+testnet, "
"com-isolated_margin+testnet, com-futures+testnet, jersey, us, jex, dex/chain+testnet) in a easy, fast"
", flexible, robust and fully-featured way.",
long_description=long_description,
long_description_content_type="text/markdown",
license='MIT License',
# configure api key and secret for binance.com
binance_com_api_key = ""
binance_com_api_secret = ""
# configure api key and secret for binance.je
binance_je_api_key = ""
binance_je_api_secret = ""
# configure api key and secret for binance.us
binance_us_api_key = ""
binance_us_api_secret = ""
# create instances of BinanceWebSocketApiManager
binance_com_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.com", throw_exception_if_unrepairable=True)
binance_je_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.je")
binance_us_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.us")
# set api key and secret in api manager
binance_com_websocket_api_manager.set_private_api_config(
binance_com_api_key, binance_com_api_secret)
binance_je_websocket_api_manager.set_private_api_config(
binance_je_api_key, binance_je_api_secret)
binance_us_websocket_api_manager.set_private_api_config(
binance_us_api_key, binance_us_api_secret)
# create the userData streams
binance_com_user_data_stream_id = binance_com_websocket_api_manager.create_stream(
def print_stream_data_from_stream_buffer(binance_websocket_api_manager):
while True:
if binance_websocket_api_manager.is_manager_stopping():
exit(0)
oldest_stream_data_from_stream_buffer = binance_websocket_api_manager.pop_stream_data_from_stream_buffer(
)
if oldest_stream_data_from_stream_buffer is False:
time.sleep(0.01)
else:
unicorn_fied_stream_data = UnicornFy.binance_org_websocket(
oldest_stream_data_from_stream_buffer)
print(unicorn_fied_stream_data)
# create instance of BinanceWebSocketApiManager for Binance Chain DEX
binance_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.org-testnet")
# start a worker process to move the received stream_data from the stream_buffer to a print function
worker_thread = threading.Thread(target=print_stream_data_from_stream_buffer,
args=(binance_websocket_api_manager, ))
worker_thread.start()
# userAddress streams
binance_dex_user_address = "bnb1v566f3avl2ud5z0jepazsrguzkj367snlx4jm6"
id = binance_websocket_api_manager.create_stream('orders',
binance_dex_user_address)
binance_websocket_api_manager.create_stream('accounts',
binance_dex_user_address)
binance_websocket_api_manager.create_stream('transfers',
binance_dex_user_address)
user_address_multi_stream_id = binance_websocket_api_manager.create_stream(
while True:
if binance_websocket_api_manager.is_manager_stopping():
exit(0)
oldest_stream_data_from_stream_buffer = binance_websocket_api_manager.pop_stream_data_from_stream_buffer(
)
if oldest_stream_data_from_stream_buffer is not False:
pass
#unicorn_fied_data = UnicornFy.binance_com_websocket(oldest_stream_data_from_stream_buffer)
#print(str(unicorn_fied_data))
else:
time.sleep(0.01)
try:
binance_rest_client = Client(binance_api_key, binance_api_secret)
binance_websocket_api_manager = BinanceWebSocketApiManager(
print_summary_export_path="/var/www/html/")
except requests.exceptions.ConnectionError:
print("No internet connection?")
sys.exit(1)
# start a worker process to move the received stream_data from the stream_buffer to a print function
worker_thread = threading.Thread(target=print_stream_data_from_stream_buffer,
args=(binance_websocket_api_manager, ))
worker_thread.start()
data = binance_rest_client.get_all_tickers()
for item in data:
markets.append(item['symbol'])
binance_websocket_api_manager.set_private_api_config(binance_api_key,
binance_api_secret)
def run(self):
bot_sendtext("SSRM START")
binance_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.com", output_default="UnicornFy")
binance_websocket_api_manager.create_stream(['kline_1m', 'kline_1h'],
[f'{self.symbol}usdt'],
stream_label="UnicornFy",
output="UnicornFy")
binance_websocket_api_manager.create_stream(['depth5'],
[self.main_symbol],
stream_label="UnicornFy",
output="UnicornFy")
while self.bot_ping:
if self.status:
self.status = False
binance_websocket_api_manager.create_stream(
['kline_1m', 'kline_1h', 'depth5'], [f'{self.symbol}usdt'],
stream_label="UnicornFy",
output="UnicornFy")
binance_websocket_api_manager.create_stream(
['depth5'],
[f'{self.symbol}upusdt', f'{self.symbol}downusdt'],
stream_label="UnicornFy",
output="UnicornFy")
print(
f"PARSER RESTART at {datetime.now().strftime('%H:%M:%S')}")
else:
try:
if binance_websocket_api_manager.is_manager_stopping():
exit(0)
self.status = True
stream_buffer = binance_websocket_api_manager.pop_stream_data_from_stream_buffer(
)
if stream_buffer:
try:
if stream_buffer['event_type'] == "depth":
if stream_buffer[
'symbol'] == self.main_symbol.upper():
self.my_ask = float(
stream_buffer['asks'][0][0])
self.my_bid = float(
stream_buffer['bids'][0][0])
if self.order:
if self.my_ask > self.my_tp:
self.close_tp_order()
""" проверить по ID и сохранить ордер в БД"""
if self.my_bid <= self.my_sl:
""" отменить TP, Проверить и сохранить ордер в БД"""
self.close_sl_order()
else:
self.amount = self.min_amount / float(
stream_buffer['asks'][0][0])
else:
if stream_buffer['event_type'] == "kline":
if stream_buffer['kline'][
'interval'] == "1m":
if stream_buffer[
'event_time'] >= stream_buffer[
'kline'][
'kline_close_time']:
new_row = [
stream_buffer['kline']
['kline_start_time'],
stream_buffer['kline']
['open_price'],
stream_buffer['kline']
['high_price'],
stream_buffer['kline']
['low_price'],
stream_buffer['kline']
['close_price'],
stream_buffer['kline']
['base_volume'],
stream_buffer['kline']
['kline_close_time'], None,
None, None, None, None
]
self.main_data.append(new_row)
del self.main_data[0]
self.algorithm()
elif stream_buffer['kline'][
'interval'] == "1h":
if stream_buffer[
'event_time'] >= stream_buffer[
'kline'][
'kline_close_time']:
new_row = [
stream_buffer['kline']
['kline_start_time'],
stream_buffer['kline']
['open_price'],
stream_buffer['kline']
['high_price'],
stream_buffer['kline']
['low_price'],
stream_buffer['kline']
['close_price'],
stream_buffer['kline']
['base_volume'],
stream_buffer['kline']
['kline_close_time'], None,
None, None, None, None
]
self.main_data_hour.append(new_row)
del self.main_data_hour[0]
self.algorithm_supertrend()
time.sleep(0.2)
except KeyError:
print(f"Exception :\n {stream_buffer}")
time.sleep(0.5)
else:
time.sleep(0.01)
except Exception as exc:
self.status = True
traceback.print_exc()
time.sleep(30)
import time
import threading
import logging
# import class to process stream data
from example_process_streams import BinanceWebSocketApiProcessStreams
# https://docs.python.org/3/library/logging.html#logging-levels
logging.basicConfig(
level=logging.DEBUG,
filename=os.path.basename(__file__) + '.log',
format="{asctime} [{levelname:8}] {process} {thread} {module}: {message}",
style="{")
# create instance of BinanceWebSocketApiManager and provide the function for stream processing
binance_websocket_api_manager = BinanceWebSocketApiManager(
BinanceWebSocketApiProcessStreams.process_stream_data)
# binance_websocket_api_manager = BinanceWebSocketApiManager(exchange="binance.com")
def print_stream_data_from_stream_buffer(binance_websocket_api_manager):
while True:
if binance_websocket_api_manager.is_manager_stopping():
exit(0)
oldest_stream_data_from_stream_buffer = binance_websocket_api_manager.pop_stream_data_from_stream_buffer(
)
if oldest_stream_data_from_stream_buffer is False:
time.sleep(0.01)
else:
print(oldest_stream_data_from_stream_buffer)
pass
def setUp(self):
self.binance_com_testnet_api_key = BINANCE_COM_API_KEY
self.binance_com_testnet_api_secret = BINANCE_COM_API_SECRET
self.binance_com_testnet_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.com-testnet")
def run(self):
bot_sendtext(f"FUTURE START {self.symbol.upper()}USDT")
self.binance_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.com-futures", output_default="dict")
self.binance_websocket_api_manager.create_stream(
['kline_1m', 'kline_1h'], [f'{self.symbol}usdt'],
stream_label="UnicornFy",
output="UnicornFy")
self.binance_websocket_api_manager.create_stream(
['trade'], [f'{self.symbol}usdt'], output="UnicornFy")
self.binance_websocket_api_manager.create_stream(
'arr',
'!userData',
api_key=self.api_key,
api_secret=self.api_secret,
output="dict")
while self.bot_ping:
if self.status:
self.status = False
self.binance_websocket_api_manager.create_stream(
['kline_1m', 'kline_1h'], [f'{self.symbol}usdt'],
stream_label="UnicornFy",
output="UnicornFy")
self.binance_websocket_api_manager.create_stream(
['trade'], [f'{self.symbol}usdt'], output="UnicornFy")
self.binance_websocket_api_manager.create_stream(
'arr',
'!userData',
api_key=self.api_key,
api_secret=self.api_secret,
output="dict")
print(
f"PARSER RESTART at {datetime.now().strftime('%H:%M:%S')}")
else:
try:
if self.binance_websocket_api_manager.is_manager_stopping(
):
exit(0)
self.status = True
stream_buffer = self.binance_websocket_api_manager.pop_stream_data_from_stream_buffer(
)
if stream_buffer:
try:
if "e" in stream_buffer:
if stream_buffer['e'] == 'ACCOUNT_UPDATE':
if stream_buffer['a']['P'][0][
's'] == f'{self.symbol}usdt'.upper(
) and stream_buffer['a']['P'][0][
'pa'] == "0":
if self.order == 1:
if self.trade >= self.my_price:
self.close_tp_order()
if self.trade < self.my_price:
self.close_sl_order()
elif self.order == 2:
if self.trade > self.my_price:
self.close_sl_order()
if self.trade <= self.my_price:
self.close_tp_order()
elif stream_buffer['event_type'] == "trade":
self.trade = float(stream_buffer['price'])
self.amount = self.min_amount / self.trade
else:
if stream_buffer['kline']['interval'] == "1m":
if stream_buffer[
'event_time'] >= stream_buffer[
'kline']['kline_close_time']:
new_row = [
stream_buffer['kline']
['kline_start_time'],
stream_buffer['kline']
['open_price'],
stream_buffer['kline']
['high_price'],
stream_buffer['kline']
['low_price'],
stream_buffer['kline']
['close_price'],
stream_buffer['kline']
['base_volume'],
stream_buffer['kline']
['kline_close_time'], None, None,
None, None, None
]
self.main_data.append(new_row)
del self.main_data[0]
self.algorithm()
elif stream_buffer['kline'][
'interval'] == "1h":
if stream_buffer[
'event_time'] >= stream_buffer[
'kline']['kline_close_time']:
new_row = [
stream_buffer['kline']
['kline_start_time'],
stream_buffer['kline']
['open_price'],
stream_buffer['kline']
['high_price'],
stream_buffer['kline']
['low_price'],
stream_buffer['kline']
['close_price'],
stream_buffer['kline']
['base_volume'],
stream_buffer['kline']
['kline_close_time'], None, None,
None, None, None
]
self.main_data_hour.append(new_row)
del self.main_data_hour[0]
self.algorithm_rsi()
time.sleep(0.1)
except KeyError:
print(f"Exception :\n {stream_buffer}")
time.sleep(0.5)
else:
time.sleep(0.01)
except Exception as exc:
self.status = True
traceback.print_exc()
time.sleep(30)
def run(self):
bot_sendtext("NEW BOT START")
binance_websocket_api_manager = BinanceWebSocketApiManager(
exchange="binance.com", output_default="UnicornFy")
binance_websocket_api_manager.create_stream(['kline_1m'],
[f'{self.symbol}usdt'],
stream_label="UnicornFy",
output="UnicornFy")
binance_websocket_api_manager.create_stream(['depth5'],
[f'{self.symbol}upusdt'],
stream_label="UnicornFy",
output="UnicornFy")
binance_websocket_api_manager.create_stream(['depth5'],
[f'{self.symbol}downusdt'],
stream_label="UnicornFy",
output="UnicornFy")
while True:
if self.status:
self.status = False
binance_websocket_api_manager.create_stream(
['kline_1m'], [f'{self.symbol}usdt'],
stream_label="UnicornFy",
output="UnicornFy")
binance_websocket_api_manager.create_stream(
['depth5'], [f'{self.symbol}upusdt'],
stream_label="UnicornFy",
output="UnicornFy")
binance_websocket_api_manager.create_stream(
['depth5'], [f'{self.symbol}downusdt'],
stream_label="UnicornFy",
output="UnicornFy")
print(
f"PARSER RESTART at {datetime.now().strftime('%H:%M:%S')}")
else:
try:
if binance_websocket_api_manager.is_manager_stopping():
exit(0)
self.status = True
stream_buffer = binance_websocket_api_manager.pop_stream_data_from_stream_buffer(
)
if stream_buffer:
try:
if stream_buffer['event_type'] == "depth":
if stream_buffer[
'symbol'] == f"{self.symbol.upper()}UPUSDT":
self.my_ask_up = float(
stream_buffer['asks'][0][0])
self.my_bid_up = float(
stream_buffer['bids'][0][0])
# print(f"{self.symbol.upper()}UPUSDT", self.my_bid_up)
if self.order == 1:
if self.my_bid_up <= self.my_sl:
self.close_order(self.order)
elif self.my_bid_up >= self.my_tp:
self.close_order(self.order)
else:
self.my_ask_down = float(
stream_buffer['asks'][0][0])
self.my_bid_down = float(
stream_buffer['bids'][0][0])
# print(f"{self.symbol.upper()}DOWNUSDT", self.my_bid_up)
if self.order == 2:
if self.my_bid_down <= self.my_sl:
self.close_order(self.order)
elif self.my_bid_down >= self.my_tp:
self.close_order(self.order)
if stream_buffer['event_type'] == "kline":
if stream_buffer['event_time'] >= stream_buffer[
'kline']['kline_close_time']:
new_row = [
stream_buffer['kline']
['kline_start_time'],
stream_buffer['kline']['open_price'],
stream_buffer['kline']['high_price'],
stream_buffer['kline']['low_price'],
stream_buffer['kline']['close_price'],
stream_buffer['kline']['base_volume'],
stream_buffer['kline']
['kline_close_time'], None, None, None,
None, None
]
self.main_data.append(new_row)
del self.main_data[0]
self.algorithm()
time.sleep(0.5)
except KeyError:
print(f"Exception :\n {stream_buffer}")
time.sleep(0.5)
else:
time.sleep(0.01)
except Exception as exc:
self.status = True
traceback.print_exc()
time.sleep(30)
