async def docker_ipc_with_generator(method_name: str, *args, **kwargs) -> AsyncIterable[str]: from hummingbot.client.hummingbot_application import HummingbotApplication global _hummingbot_pipe if _hummingbot_pipe is None: raise RuntimeError( "Not in the main process, or hummingbot wasn't started via `fork_and_start()`." ) try: _hummingbot_pipe.send((method_name, args, kwargs)) while True: data = await _hummingbot_pipe.coro_recv() if data is None: break if isinstance(data, Exception): HummingbotApplication.main_application().notify( "\nError: Unable to communicate with docker socket. " "\nEnsure dockerd is running and /var/run/docker.sock exists, then restart Hummingbot." ) raise data yield data except Exception as e: # unable to communicate with docker socket HummingbotApplication.main_application().notify( "\nError: Unable to communicate with docker socket. " "\nEnsure dockerd is running and /var/run/docker.sock exists, then restart Hummingbot." ) raise e
def notify_hb_app(self, msg: str): """ Send a message to the hummingbot application """ if self._hb_app_notification: from hummingbot.client.hummingbot_application import HummingbotApplication HummingbotApplication.main_application()._notify(msg)
async def start_existing_gateway_container( client_config_map: "ClientConfigAdapter"): container_info: Optional[Dict[ str, Any]] = await detect_existing_gateway_container(client_config_map) if container_info is not None and container_info["State"] != "running": from hummingbot.client.hummingbot_application import HummingbotApplication HummingbotApplication.main_application().logger().info( "Starting existing Gateway container...") await docker_ipc("start", get_gateway_container_name(client_config_map))
async def main_async(client_config_map: ClientConfigAdapter): await create_yml_files_legacy() # This init_logging() call is important, to skip over the missing config warnings. init_logging("hummingbot_logs.yml", client_config_map) AllConnectorSettings.initialize_paper_trade_settings( client_config_map.paper_trade.paper_trade_exchanges) hb = HummingbotApplication.main_application(client_config_map) # The listener needs to have a named variable for keeping reference, since the event listener system # uses weak references to remove unneeded listeners. start_listener: UIStartListener = UIStartListener(hb) hb.app.add_listener(HummingbotUIEvent.Start, start_listener) tasks: List[Coroutine] = [ hb.run(), start_existing_gateway_container(client_config_map) ] if client_config_map.debug_console: if not hasattr(__builtins__, "help"): import _sitebuiltins __builtins__.help = _sitebuiltins._Helper() from hummingbot.core.management.console import start_management_console management_port: int = detect_available_port(8211) tasks.append( start_management_console(locals(), host="localhost", port=management_port)) await safe_gather(*tasks)
def non_trading_connector_instance_with_default_configuration( self, trading_pairs: Optional[List[str]] = None) -> 'ConnectorBase': from hummingbot.client.config.config_helpers import ClientConfigAdapter from hummingbot.client.hummingbot_application import HummingbotApplication trading_pairs = trading_pairs or [] connector_class = getattr(importlib.import_module(self.module_path()), self.class_name()) kwargs = {} if isinstance(self.config_keys, Dict): kwargs = { key: (config.value or "") for key, config in self.config_keys.items() } # legacy elif self.config_keys is not None: kwargs = { traverse_item.attr: traverse_item.value.get_secret_value() if isinstance(traverse_item.value, SecretStr) else traverse_item.value or "" for traverse_item in ClientConfigAdapter( self.config_keys).traverse() if traverse_item.attr != "connector" } kwargs = self.conn_init_parameters(kwargs) kwargs = self.add_domain_parameter(kwargs) kwargs.update(trading_pairs=trading_pairs, trading_required=False) kwargs["client_config_map"] = HummingbotApplication.main_application( ).client_config_map connector = connector_class(**kwargs) return connector
async def main(): await create_yml_files() # This init_logging() call is important, to skip over the missing config warnings. init_logging("hummingbot_logs.yml") read_configs_from_yml() if __name__ == '__main__': hb = HummingbotApplication.main_application() with patch_stdout(log_field=hb.app.log_field): dev_mode = check_dev_mode() if dev_mode: hb.app.log( "Running from dev branches. Full remote logging will be enabled." ) init_logging( "hummingbot_logs.yml", override_log_level=global_config_map.get("log_level").value, dev_mode=dev_mode) tasks: List[Coroutine] = [hb.run()] if global_config_map.get("debug_console").value: management_port: int = detect_available_port(8211) tasks.append( start_management_console(locals(), host="localhost", port=management_port)) await asyncio.gather(*tasks)
async def set_up_class(cls): add_files_extension(settings.CONF_FILE_PATH, [".yml", ".json"], ".temp") asyncio.ensure_future(hb_main()) cls.hb = HummingbotApplication.main_application() await wait_til(lambda: 'Enter "config" to create a bot' in cls.hb.app. output_field.document.text)
def get_gateway_status(): from hummingbot.client.hummingbot_application import HummingbotApplication hb = HummingbotApplication.main_application() gateway_status = "RUNNING" if hb._gateway_monitor.current_status is GatewayStatus.ONLINE else "STOPPED" gateway_conn_status = hb._gateway_monitor.current_connector_conn_status.name style = "class:log_field" return [(style, f"Gateway: {gateway_status}, {gateway_conn_status}")]
async def start_trade_monitor(trade_monitor): from hummingbot.client.hummingbot_application import HummingbotApplication hb = HummingbotApplication.main_application() trade_monitor.log("Trades: 0, Total P&L: 0.00, Return %: 0.00%") total_trades = 0 return_pcts = [] pnls = [] quote_asset = "" while True: if hb.strategy_task is not None and not hb.strategy_task.done(): if all(market.ready for market in hb.markets.values()): trades: List[TradeFill] = hb._get_trades_from_session(int(hb.init_time * 1e3), config_file_path=hb.strategy_file_name) if len(trades) > total_trades: total_trades = len(trades) market_info: Set[Tuple[str, str]] = set((t.market, t.symbol) for t in trades) for market, symbol in market_info: quote_asset = symbol.split("-")[1] # Note that the qiote asset of the last pair is assumed to be the quote asset of P&L for simplicity cur_trades = [t for t in trades if t.market == market and t.symbol == symbol] cur_balances = await hb.get_current_balances(market) cur_price = await get_last_price(market.replace("_PaperTrade", ""), symbol) perf = calculate_performance_metrics(symbol, cur_trades, cur_balances, cur_price) return_pcts.append(perf.return_pct) pnls.append(perf.total_pnl) avg_return = sum(return_pcts) / len(return_pcts) if len(return_pcts) > 0 else s_decimal_0 total_pnls = sum(pnls) # Note that this sum doesn't handles cases with different multiple pairs for simplisity trade_monitor.log(f"Trades: {total_trades}, Total P&L: {smart_round(total_pnls)} {quote_asset}, Return %: {avg_return:.2%}") return_pcts.clear() pnls.clear() await asyncio.sleep(2) # sleeping for longer to manage resources
async def quick_start(args): config_file_name = args.config_file_name wallet = args.wallet password = args.config_password if args.auto_set_permissions is not None: autofix_permissions(args.auto_set_permissions) if password is not None and not Security.login(password): logging.getLogger().error("Invalid password.") return await Security.wait_til_decryption_done() await create_yml_files() init_logging("hummingbot_logs.yml") read_system_configs_from_yml() hb = HummingbotApplication.main_application() # Todo: validate strategy and config_file_name before assinging if config_file_name is not None: hb.strategy_file_name = config_file_name hb.strategy_name = update_strategy_config_map_from_file( os.path.join(CONF_FILE_PATH, config_file_name)) # To ensure quickstart runs with the default value of False for kill_switch_enabled if not present if not global_config_map.get("kill_switch_enabled"): global_config_map.get("kill_switch_enabled").value = False if wallet and password: global_config_map.get("ethereum_wallet").value = wallet if hb.strategy_name and hb.strategy_file_name: if not all_configs_complete(hb.strategy_name): hb.status() with patch_stdout(log_field=hb.app.log_field): dev_mode = check_dev_mode() if dev_mode: hb.app.log( "Running from dev branches. Full remote logging will be enabled." ) log_level = global_config_map.get("log_level").value init_logging("hummingbot_logs.yml", override_log_level=log_level, dev_mode=dev_mode) if hb.strategy_file_name is not None and hb.strategy_name is not None: await write_config_to_yml(hb.strategy_name, hb.strategy_file_name) hb.start(log_level) tasks: List[Coroutine] = [hb.run()] if global_config_map.get("debug_console").value: management_port: int = detect_available_port(8211) tasks.append( start_management_console(locals(), host="localhost", port=management_port)) await safe_gather(*tasks)
async def main(): await create_yml_files() # This init_logging() call is important, to skip over the missing config warnings. init_logging("hummingbot_logs.yml") read_system_configs_from_yml() hb = HummingbotApplication.main_application() with patch_stdout(log_field=hb.app.log_field): dev_mode = check_dev_mode() if dev_mode: hb.app.log("Running from dev branches. Full remote logging will be enabled.") init_logging("hummingbot_logs.yml", override_log_level=global_config_map.get("log_level").value, dev_mode=dev_mode) tasks: List[Coroutine] = [hb.run()] if global_config_map.get("debug_console").value: if not hasattr(__builtins__, "help"): import _sitebuiltins __builtins__.help = _sitebuiltins._Helper() from hummingbot.core.management.console import start_management_console management_port: int = detect_available_port(8211) tasks.append(start_management_console(locals(), host="localhost", port=management_port)) await safe_gather(*tasks)
def notify(self, msg: str): from . import INFO self.log(INFO, msg) if not HummingbotLogger.is_testing_mode(): from hummingbot.client.hummingbot_application import HummingbotApplication hummingbot_app: HummingbotApplication = HummingbotApplication.main_application() hummingbot_app._notify(f"({pd.Timestamp.fromtimestamp(int(time.time()))}) {msg}")
async def get_connector_price(self, connector_name: str, chain: str, network: str, trading_pair: str, is_buy: bool, amount: Decimal) -> Optional[Decimal]: key: GatewayPriceShimKey = GatewayPriceShimKey( connector_name=connector_name, chain=chain, network=network, trading_pair=trading_pair) if key not in self._shim_entries: return None shim_entry: GatewayPriceShimEntry = self._shim_entries[key] exchange_market: Optional[ ExchangeBase] = HummingbotApplication.main_application( ).markets.get(shim_entry.from_exchange) if exchange_market is None: self.logger().warning( f"Gateway price shim failure: " f"reference exchange market '{shim_entry.from_exchange}' not found. " f"Going to use on-chain prices instead.") return None exchange_price: Decimal = await exchange_market.get_quote_price( shim_entry.from_trading_pair, is_buy, amount) if key in self._delta_entries: delta_entry: GatewayPriceDeltaEntry = self._delta_entries[key] now: float = time.time() if now <= delta_entry.end_timestamp: exchange_price += delta_entry.delta else: del self._delta_entries[key] return exchange_price
async def main(): chdir_to_data_directory() await create_yml_files() # This init_logging() call is important, to skip over the missing config warnings. init_logging("hummingbot_logs.yml") hb = HummingbotApplication.main_application() setHummingInstance(hb) read_configs_from_yml() ExchangeRateConversion.get_instance().start() with patch_stdout(log_field=hb.app.log_field): dev_mode = check_dev_mode() if dev_mode: hb.app.log( "Running from dev branches. Full remote logging will be enabled." ) init_logging( "hummingbot_logs.yml", override_log_level=global_config_map.get("log_level").value, dev_mode=dev_mode) tasks: List[Coroutine] = [hb.run(), sio.connect('ws://localhost:5000')] await safe_gather(*tasks)
async def quick_start(): try: args = CmdlineParser().parse_args() strategy = args.strategy config_file_name = args.config_file_name wallet = args.wallet password = args.config_password await create_yml_files() init_logging("hummingbot_logs.yml") read_configs_from_yml() ExchangeRateConversion.get_instance().start() await ExchangeRateConversion.get_instance().wait_till_ready() hb = HummingbotApplication.main_application() in_memory_config_map.get("password").value = password in_memory_config_map.get("strategy").value = strategy in_memory_config_map.get("strategy").validate(strategy) in_memory_config_map.get("strategy_file_path").value = config_file_name in_memory_config_map.get("strategy_file_path").validate(config_file_name) # To ensure quickstart runs with the default value of False for kill_switch_enabled if not present if not global_config_map.get("kill_switch_enabled"): global_config_map.get("kill_switch_enabled").value = False if wallet and password: global_config_map.get("wallet").value = wallet hb.acct = unlock_wallet(public_key=wallet, password=password) if not hb.config_complete: config_map = load_required_configs() empty_configs = [key for key, config in config_map.items() if config.value is None and config.required] empty_config_description: str = "\n- ".join([""] + empty_configs) raise ValueError(f"Missing empty configs: {empty_config_description}\n") with patch_stdout(log_field=hb.app.log_field): dev_mode = check_dev_mode() if dev_mode: hb.app.log("Running from dev branches. Full remote logging will be enabled.") log_level = global_config_map.get("log_level").value init_logging("hummingbot_logs.yml", override_log_level=log_level, dev_mode=dev_mode, strategy_file_path=config_file_name) await write_config_to_yml() hb.start(log_level) tasks: List[Coroutine] = [hb.run()] if global_config_map.get("debug_console").value: management_port: int = detect_available_port(8211) tasks.append(start_management_console(locals(), host="localhost", port=management_port)) await safe_gather(*tasks) except Exception as e: # In case of quick start failure, start the bot normally to allow further configuration logging.getLogger().warning(f"Bot config incomplete: {str(e)}. Starting normally...") await normal_start()
def test_get_strategy_file(self): hb = HummingbotApplication.main_application() hb._strategy_file_name = "some_strategy.yml" res = get_strategy_file() style, text = res[0] self.assertEqual("class:log-field", style) self.assertEqual(f"Strategy File: {hb._strategy_file_name}", text)
def test_get_active_strategy(self): hb = HummingbotApplication.main_application() hb.strategy_name = "SomeStrategy" res = get_active_strategy() style, text = res[0] self.assertEqual("class:log-field", style) self.assertEqual(f"Strategy: {hb.strategy_name}", text)
async def quick_start(): try: args = CmdlineParser().parse_args() strategy = args.strategy config_file_name = args.config_file_name wallet = args.wallet wallet_password = args.wallet_password await create_yml_files() init_logging("hummingbot_logs.yml") read_configs_from_yml() hb = HummingbotApplication.main_application() in_memory_config_map.get("strategy").value = strategy in_memory_config_map.get("strategy").validate(strategy) in_memory_config_map.get("strategy_file_path").value = config_file_name in_memory_config_map.get("strategy_file_path").validate( config_file_name) if wallet and wallet_password: global_config_map.get("wallet").value = wallet hb.acct = unlock_wallet(public_key=wallet, password=wallet_password) if not hb.config_complete: empty_configs = hb._get_empty_configs() empty_config_description: str = "\n- ".join([""] + empty_configs) raise ValueError( f"Missing empty configs: {empty_config_description}\n") with patch_stdout(log_field=hb.app.log_field): dev_mode = check_dev_mode() if dev_mode: hb.app.log( "Running from dev branches. Full remote logging will be enabled." ) log_level = global_config_map.get("log_level").value init_logging("hummingbot_logs.yml", override_log_level=log_level, dev_mode=dev_mode) hb.start(log_level) tasks: List[Coroutine] = [hb.run()] if global_config_map.get("debug_console").value: management_port: int = detect_available_port(8211) tasks.append( start_management_console(locals(), host="localhost", port=management_port)) await asyncio.gather(*tasks) except Exception as e: # In case of quick start failure, start the bot normally to allow further configuration logging.getLogger().warning( f"Bot config incomplete: {str(e)}. Starting normally...") await normal_start()
def __init__(self, client_config_map: Optional["ClientConfigAdapter"] = None): if client_config_map is None: from hummingbot.client.hummingbot_application import HummingbotApplication client_config_map = HummingbotApplication.main_application().client_config_map api_host = client_config_map.gateway.gateway_api_host api_port = client_config_map.gateway.gateway_api_port if GatewayHttpClient.__instance is None: self._base_url = f"https://{api_host}:{api_port}" self._client_confi_map = client_config_map GatewayHttpClient.__instance = self
async def set_up_class(cls): add_files_extension(settings.CONF_FILE_PATH, [".yml", ".json"], ".temp") asyncio.ensure_future(hb_main()) cls.hb = HummingbotApplication.main_application() await wait_til( lambda: ExchangeRateConversion.get_instance()._ready_notifier. is_set(), 20) await wait_til(lambda: 'Enter "config" to create a bot' in cls.hb.app. output_field.document.text)
async def quick_start(args: argparse.Namespace, secrets_manager: BaseSecretsManager): config_file_name = args.config_file_name client_config = load_client_config_map_from_file() if args.auto_set_permissions is not None: autofix_permissions(args.auto_set_permissions) if not Security.login(secrets_manager): logging.getLogger().error("Invalid password.") return await Security.wait_til_decryption_done() await create_yml_files_legacy() init_logging("hummingbot_logs.yml", client_config) await read_system_configs_from_yml() AllConnectorSettings.initialize_paper_trade_settings( client_config.paper_trade.paper_trade_exchanges) hb = HummingbotApplication.main_application() # Todo: validate strategy and config_file_name before assinging strategy_config = None if config_file_name is not None: hb.strategy_file_name = config_file_name strategy_config = await load_strategy_config_map_from_file( STRATEGIES_CONF_DIR_PATH / config_file_name) hb.strategy_name = (strategy_config.strategy if isinstance( strategy_config, BaseStrategyConfigMap) else strategy_config.get("strategy").value) hb.strategy_config_map = strategy_config if strategy_config is not None: if not all_configs_complete(strategy_config, hb.client_config_map): hb.status() # The listener needs to have a named variable for keeping reference, since the event listener system # uses weak references to remove unneeded listeners. start_listener: UIStartListener = UIStartListener(hb) hb.app.add_listener(HummingbotUIEvent.Start, start_listener) tasks: List[Coroutine] = [ hb.run(), start_existing_gateway_container(client_config) ] if client_config.debug_console: management_port: int = detect_available_port(8211) tasks.append( start_management_console(locals(), host="localhost", port=management_port)) await safe_gather(*tasks)
async def quick_start(args): config_file_name = args.config_file_name wallet = args.wallet password = args.config_password if args.auto_set_permissions is not None: autofix_permissions(args.auto_set_permissions) if password is not None and not Security.login(password): logging.getLogger().error("Invalid password.") return await Security.wait_til_decryption_done() await create_yml_files() init_logging("hummingbot_logs.yml") await read_system_configs_from_yml() AllConnectorSettings.initialize_paper_trade_settings( global_config_map.get("paper_trade_exchanges").value) hb = HummingbotApplication.main_application() # Todo: validate strategy and config_file_name before assinging if config_file_name is not None: hb.strategy_file_name = config_file_name hb.strategy_name = await update_strategy_config_map_from_file( os.path.join(CONF_FILE_PATH, config_file_name)) # To ensure quickstart runs with the default value of False for kill_switch_enabled if not present if not global_config_map.get("kill_switch_enabled"): global_config_map.get("kill_switch_enabled").value = False if wallet and password: global_config_map.get("ethereum_wallet").value = wallet if hb.strategy_name and hb.strategy_file_name: if not all_configs_complete(hb.strategy_name): hb.status() # The listener needs to have a named variable for keeping reference, since the event listener system # uses weak references to remove unneeded listeners. start_listener: UIStartListener = UIStartListener(hb) hb.app.add_listener(HummingbotUIEvent.Start, start_listener) tasks: List[Coroutine] = [hb.run()] if global_config_map.get("debug_console").value: management_port: int = detect_available_port(8211) tasks.append( start_management_console(locals(), host="localhost", port=management_port)) await safe_gather(*tasks)
async def docker_ipc(method_name: str, *args, **kwargs) -> Any: from hummingbot.client.hummingbot_application import HummingbotApplication global _hummingbot_pipe if _hummingbot_pipe is None: raise RuntimeError( "Not in the main process, or hummingbot wasn't started via `fork_and_start()`." ) try: _hummingbot_pipe.send((method_name, args, kwargs)) data = await _hummingbot_pipe.coro_recv() if isinstance(data, Exception): raise data return data except Exception as e: # unable to communicate with docker socket HummingbotApplication.main_application().notify( "Notice: Hummingbot is unable to communicate with Docker. If you need gateway for DeFi," "\nmake sure Docker is on, then restart Hummingbot. Otherwise, ignore this message." ) raise e
async def stop_gateway(): from hummingbot.client.hummingbot_application import HummingbotApplication try: response = await docker_ipc( "containers", all=True, filters={"name": get_gateway_container_name()}) if len(response) == 0: raise ValueError( f"Gateway container {get_gateway_container_name()} not found.") container_info = response[0] if container_info["State"] != "running": HummingbotApplication.main_application().notify( f"Gateway container {container_info['Id']} not running.") return await docker_ipc( "stop", container=container_info["Id"], ) HummingbotApplication.main_application().notify( f"Gateway container {container_info['Id']} successfully stopped.") except Exception as e: HummingbotApplication.main_application().notify( f"Error occurred stopping Gateway container. {e}")
async def start_trade_monitor(trade_monitor): from hummingbot.client.hummingbot_application import HummingbotApplication hb = HummingbotApplication.main_application() trade_monitor.log("Trades: 0, Total P&L: 0.00, Return %: 0.00%") return_pcts = [] pnls = [] while True: try: if hb.strategy_task is not None and not hb.strategy_task.done(): if all(market.ready for market in hb.markets.values()): with hb.trade_fill_db.get_new_session() as session: trades: List[TradeFill] = hb._get_trades_from_session( int(hb.init_time * 1e3), session=session, config_file_path=hb.strategy_file_name) if len(trades) > 0: market_info: Set[Tuple[str, str]] = set( (t.market, t.symbol) for t in trades) for market, symbol in market_info: cur_trades = [ t for t in trades if t.market == market and t.symbol == symbol ] cur_balances = await hb.get_current_balances( market) perf = await PerformanceMetrics.create( symbol, cur_trades, cur_balances) return_pcts.append(perf.return_pct) pnls.append(perf.total_pnl) avg_return = sum(return_pcts) / len( return_pcts) if len( return_pcts) > 0 else s_decimal_0 quote_assets = set( t.symbol.split("-")[1] for t in trades) if len(quote_assets) == 1: total_pnls = f"{PerformanceMetrics.smart_round(sum(pnls))} {list(quote_assets)[0]}" else: total_pnls = "N/A" trade_monitor.log( f"Trades: {len(trades)}, Total P&L: {total_pnls}, " f"Return %: {avg_return:.2%}") return_pcts.clear() pnls.clear() await _sleep(2) # sleeping for longer to manage resources except asyncio.CancelledError: raise except Exception: hb.logger().exception("start_trade_monitor failed.")
def network(self, log_msg: str, app_warning_msg: Optional[str] = None, *args, **kwargs): from hummingbot.client.hummingbot_application import HummingbotApplication from . import NETWORK self.log(NETWORK, log_msg, *args, **kwargs) if app_warning_msg is not None and not HummingbotLogger.is_testing_mode(): app_warning: ApplicationWarning = ApplicationWarning( time.time(), self.name, self.findCaller(), app_warning_msg ) self.warning(app_warning.warning_msg) hummingbot_app: HummingbotApplication = HummingbotApplication.main_application() hummingbot_app.add_application_warning(app_warning)
async def show_order_book(self): from hummingbot.client.hummingbot_application import HummingbotApplication main_app = HummingbotApplication.main_application() if self._trading_pair not in self._exchange.order_books: self.logger().error(f"Invalid market {self._trading_pair} on {self._exchange.name} connector.") raise ValueError(f"Invalid market {self._trading_pair} on {self._exchange.name} connector.") await main_app.stop_live_update() main_app.app.live_updates = True while main_app.app.live_updates: await main_app.cls_display_delay(self.get_order_book() + "\n\n Press escape key to stop update.", 0.5) # NOTE: Currently there is no way for users to re-trigger the live orderbook display with this strategy. self.notify_hb_app("Stopped live orderbook display update. To show live orderbook again, re-run the strategy by running the `stop` and `start` command.")
async def main(): await create_yml_files() init_logging("hummingbot_logs.yml") read_configs_from_yml() hb = HummingbotApplication.main_application() hb.acct = unlock_wallet(public_key=WALLET_PUBLIC_KEY, password=WALLET_PASSWORD) with patch_stdout(log_field=hb.app.log_field): init_logging("hummingbot_logs.yml", override_log_level=global_config_map.get("log_level").value) logging.getLogger().info("____DEV_MODE__start_directly__") in_memory_config_map.get("strategy").value = STRATEGY in_memory_config_map.get("strategy").validate(STRATEGY) in_memory_config_map.get("strategy_file_path").value = STRATEGY_PATH in_memory_config_map.get("strategy_file_path").validate(STRATEGY_PATH) global_config_map.get("wallet").value = WALLET_PUBLIC_KEY tasks: List[Coroutine] = [hb.run()] await asyncio.gather(*tasks)
async def handle_command(command): hb = HummingbotApplication.main_application() try: await hb._handle_command(command) except: pass if command == "status": try: with open('data/status.txt', 'r') as f: return (f.read()) except: return ("Not started.") if command == "exit": try: with open('data/status.txt', 'w') as outfile: outfile.write("Stopped.") except: print("") return "OK"
async def start_gateway(client_config_map: "ClientConfigAdapter"): from hummingbot.client.hummingbot_application import HummingbotApplication try: response = await docker_ipc( "containers", all=True, filters={"name": get_gateway_container_name(client_config_map)}) if len(response) == 0: raise ValueError( f"Gateway container {get_gateway_container_name(client_config_map)} not found. " ) container_info = response[0] if container_info["State"] == "running": HummingbotApplication.main_application().notify( f"Gateway container {container_info['Id']} already running.") return await docker_ipc("start", container=container_info["Id"]) HummingbotApplication.main_application().notify( f"Gateway container {container_info['Id']} has started.") except Exception as e: HummingbotApplication.main_application().notify( f"Error occurred starting Gateway container. {e}")