update isolated_margin user-data

example_userdata_stream.py

@@ -41,7 +41,7 @@
 
 
 # https://docs.python.org/3/library/logging.html#logging-levels
-logging.basicConfig(level=logging.DEBUG,
+logging.basicConfig(level=logging.INFO,
                     filename=os.path.basename(__file__) + '.log',
                     format="{asctime} [{levelname:8}] {process} {thread} {module}: {message}",
                     style="{")
@@ -70,21 +70,29 @@ def print_stream_data_from_stream_buffer(binance_websocket_api_manager):
 binance_us_api_key = ""
 binance_us_api_secret = ""
 
+# configure api key and secret for binance.us
+binance_com_iso_api_key = ""
+binance_com_iso_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")
+binance_com_isolated_websocket_api_manager = BinanceWebSocketApiManager(exchange="binance.com-isolated_margin")
 
 # 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)
+binance_com_isolated_websocket_api_manager.set_private_api_config(binance_com_iso_api_key, binance_com_iso_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')
+binance_com_iso_user_data_stream_id = binance_com_isolated_websocket_api_manager.create_stream('arr', '!userData',
+                                                                                               symbol="trxbtc")
 
 # 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,))
@@ -93,11 +101,15 @@ def print_stream_data_from_stream_buffer(binance_websocket_api_manager):
 worker_thread.start()
 worker_thread = threading.Thread(target=print_stream_data_from_stream_buffer, args=(binance_us_websocket_api_manager,))
 worker_thread.start()
+worker_thread = threading.Thread(target=print_stream_data_from_stream_buffer,
+                                 args=(binance_com_isolated_websocket_api_manager,))
+worker_thread.start()
 
 # monitor the streams
 while True:
     binance_com_websocket_api_manager.print_stream_info(binance_com_user_data_stream_id)
     binance_com_websocket_api_manager.print_summary()
     binance_je_websocket_api_manager.print_summary()
     binance_us_websocket_api_manager.print_summary()
+    binance_com_isolated_websocket_api_manager.print_summary()
     time.sleep(1)

unicorn_binance_websocket_api/unicorn_binance_websocket_api_connection.py

@@ -47,21 +47,22 @@
 
 
 class BinanceWebSocketApiConnection(object):
-    def __init__(self, handler_binance_websocket_api_manager, stream_id, channels, markets):
+    def __init__(self, handler_binance_websocket_api_manager, stream_id, channels, markets, symbol):
         self.handler_binance_websocket_api_manager = handler_binance_websocket_api_manager
         self.api_key = copy.deepcopy(self.handler_binance_websocket_api_manager.api_key)
         self.api_secret = copy.deepcopy(self.handler_binance_websocket_api_manager.api_secret)
         self.channels = copy.deepcopy(channels)
         self.markets = copy.deepcopy(markets)
         self.stream_id = copy.deepcopy(stream_id)
+        self.symbol = copy.deepcopy(symbol)
 
     async def __aenter__(self):
         if self.handler_binance_websocket_api_manager.is_stop_request(self.stream_id):
             self.handler_binance_websocket_api_manager.stream_is_stopping(self.stream_id)
             sys.exit(0)
         uri = self.handler_binance_websocket_api_manager.create_websocket_uri(self.channels, self.markets,
                                                                               self.stream_id, self.api_key,
-                                                                              self.api_secret)
+                                                                              self.api_secret, symbol=self.symbol)
         if uri is False:
             # cant get a valid URI, so this stream has to crash
             error_msg = "Probably no internet connection?"

unicorn_binance_websocket_api/unicorn_binance_websocket_api_manager.py

@@ -316,7 +316,7 @@ def _create_stream_thread(self, loop, stream_id, channels, markets, stream_label
         if self.is_stop_request(stream_id):
             return False
         if restart is False:
-            self._add_socket_to_socket_list(stream_id, channels, markets, stream_label, stream_buffer_name, symbol)
+            self._add_socket_to_socket_list(stream_id, channels, markets, stream_label, stream_buffer_name, symbol=symbol)
             if stream_buffer_name is not False:
                 self.stream_buffer_locks[stream_buffer_name] = threading.Lock()
                 self.stream_buffers[stream_buffer_name] = []
@@ -519,6 +519,7 @@ def _restart_stream(self, stream_id):
                                                                            self.stream_list[stream_id]['markets'],
                                                                            self.stream_list[stream_id]['stream_label'],
                                                                            self.stream_list[stream_id]['stream_buffer_name'],
+                                                                           self.stream_list[stream_id]['symbol'],
                                                                            True))
         thread.start()
         return stream_id
@@ -854,11 +855,11 @@ def create_stream(self, channels, markets, stream_label=None, stream_buffer_name
         loop = asyncio.new_event_loop()
         thread = threading.Thread(target=self._create_stream_thread, args=(loop, stream_id, channels,
                                                                            markets_new, stream_label,
-                                                                           stream_buffer_name, symbol))
+                                                                           stream_buffer_name, symbol, False))
         thread.start()
         return stream_id
 
-    def create_websocket_uri(self, channels, markets, stream_id=False, api_key=False, api_secret=False):
+    def create_websocket_uri(self, channels, markets, stream_id=False, api_key=False, api_secret=False, symbol=False):
         """
         Create a websocket URI
 
@@ -872,6 +873,8 @@ def create_websocket_uri(self, channels, markets, stream_id=False, api_key=False
         :type api_key: str
         :param api_secret: provide a valid Binance API secret
         :type api_secret: str
+        :param symbol: provide the symbol for isolated_margin user_data streams
+        :type symbol: str
         :return: str or False
         """
         payload = []
@@ -882,7 +885,7 @@ def create_websocket_uri(self, channels, markets, stream_id=False, api_key=False
         if len(channels) == 1 and len(markets) == 1:
             if "!userData" in channels or "!userData" in markets:
                 if stream_id is not False:
-                    response = self.get_listen_key_from_restclient(stream_id, api_key, api_secret)
+                    response = self.get_listen_key_from_restclient(stream_id, api_key, api_secret, symbol=symbol)
                     try:
                         if response['code'] == -2014 or response['code'] == -2015:
                             logging.critical("Received known error code from rest client: " + str(response))
@@ -1338,7 +1341,7 @@ def get_listen_key_from_restclient(self, stream_id, api_key, api_secret, symbol=
         # acquire a new listen_key:
         binance_websocket_api_restclient = BinanceWebSocketApiRestclient(self.exchange, api_key, api_secret,
                                                                          self.get_version(), self.binance_api_status,
-                                                                         symbol)
+                                                                         symbol=symbol)
         response = binance_websocket_api_restclient.get_listen_key()
         del binance_websocket_api_restclient
         if response:
@@ -1857,7 +1860,7 @@ def get_version(self):
         """
         return self.version
 
-    def get_websocket_uri_length(self, channels, markets):
+    def get_websocket_uri_length(self, channels, markets, symbol=False):
         """
         Get the length of the generated websocket URI
 
@@ -1867,7 +1870,7 @@ def get_websocket_uri_length(self, channels, markets):
         :type markets: str, tuple, list, set
         :return: int
         """
-        uri = self.create_websocket_uri(channels, markets)
+        uri = self.create_websocket_uri(channels, markets, symbol=symbol)
         return len(uri)
 
     @staticmethod

unicorn_binance_websocket_api/unicorn_binance_websocket_api_restclient.py

@@ -45,7 +45,7 @@
 
 class BinanceWebSocketApiRestclient(object):
     def __init__(self, exchange, binance_api_key, binance_api_secret, unicorn_binance_websocket_api_version,
-                 binance_api_status, symbol):
+                 binance_api_status, symbol=False):
         self.exchange = exchange
         self.api_key = copy.deepcopy(binance_api_key)
         self.api_secret = copy.deepcopy(binance_api_secret)
@@ -178,7 +178,11 @@ def get_listen_key(self):
         logging.info("BinanceWebSocketApiRestclient->get_listen_key() symbol=" + str(self.symbol))
         method = "post"
         if self.exchange == "binance.com-isolated_margin":
-            response = self._request(method, self.path_userdata, False, {'symbol': str(self.symbol)})
+            if self.symbol is False:
+                logging.critical("BinanceWebSocketApiRestclient->get_listen_key() Info: Parameter `symbol` is missing!")
+                return False
+            else:
+                response = self._request(method, self.path_userdata, False, {'symbol': str(self.symbol)})
         else:
             response = self._request(method, self.path_userdata)
         try: