def test_update_secure_config(self): password = "******" secrets_manager = ETHKeyFileSecretManger(password) store_password_verification(secrets_manager) Security.login(secrets_manager) binance_config = ClientConfigAdapter( BinanceConfigMap(binance_api_key=self.api_key, binance_api_secret=self.api_secret) ) self.async_run_with_timeout(Security.wait_til_decryption_done()) Security.update_secure_config(binance_config) self.reset_security() Security.login(secrets_manager) self.async_run_with_timeout(Security.wait_til_decryption_done(), timeout=2) binance_loaded_config = Security.decrypted_value(binance_config.connector) self.assertEqual(binance_config, binance_loaded_config) binance_config.binance_api_key = "someOtherApiKey" Security.update_secure_config(binance_config) self.reset_security() Security.login(secrets_manager) self.async_run_with_timeout(Security.wait_til_decryption_done(), timeout=2) binance_loaded_config = Security.decrypted_value(binance_config.connector) self.assertEqual(binance_config, binance_loaded_config)
def setUp(self) -> None: super().setUp() self.strategy = None self.markets = {"binance": ExchangeBase(client_config_map=ClientConfigAdapter(ClientConfigMap()))} self.notifications = [] self.log_records = [] self.base = "ETH" self.quote = "BTC" self.strategy_config_map = ClientConfigAdapter( AvellanedaMarketMakingConfigMap( exchange="binance", market=combine_to_hb_trading_pair(self.base, self.quote), execution_timeframe_mode=FromDateToDateModel( start_datetime="2021-11-18 15:00:00", end_datetime="2021-11-18 16:00:00", ), order_amount=60, order_refresh_time=60, hanging_orders_mode=TrackHangingOrdersModel( hanging_orders_cancel_pct=1, ), order_levels_mode=MultiOrderLevelModel( order_levels=4, level_distances=1, ), min_spread=2, risk_factor=1.11, order_amount_shape_factor=0.33, ) ) self.raise_exception_for_market_initialization = False self._logger = None
async def _test_create_arb_proposals(self): market_info1 = MarketTradingPairTuple( MockConnector1( client_config_map=ClientConfigAdapter(ClientConfigMap())), trading_pair, base, quote) market_info2 = MarketTradingPairTuple( MockConnector2( client_config_map=ClientConfigAdapter(ClientConfigMap())), trading_pair, base, quote) arb_proposals = await utils.create_arb_proposals( market_info1, market_info2, [], [], Decimal("1")) # there are 2 proposal combination possible - (buy_1, sell_2) and (buy_2, sell_1) self.assertEqual(2, len(arb_proposals)) # Each proposal has a buy and a sell proposal sides self.assertNotEqual(arb_proposals[0].first_side.is_buy, arb_proposals[0].second_side.is_buy) self.assertNotEqual(arb_proposals[1].first_side.is_buy, arb_proposals[1].second_side.is_buy) buy_1_sell_2_profit_pct = (Decimal("100") - Decimal("105")) / Decimal("105") self.assertEqual(buy_1_sell_2_profit_pct, arb_proposals[0].profit_pct()) buy_2_sell_1_profit_pct = (Decimal("104") - Decimal("103")) / Decimal("103") self.assertEqual(buy_2_sell_1_profit_pct, arb_proposals[1].profit_pct())
def migrate_global_config() -> List[str]: global celo_address logging.getLogger().info("\nMigrating the global config...") global_config_path = CONF_DIR_PATH / "conf_global.yml" errors = [] if global_config_path.exists(): with open(str(global_config_path), "r") as f: data = yaml.safe_load(f) del data["template_version"] client_config_map = ClientConfigAdapter(ClientConfigMap()) _migrate_global_config_modes(client_config_map, data) data.pop("kraken_api_tier", None) data.pop("key_file_path", None) celo_address = data.pop("celo_address", None) keys = list(data.keys()) for key in keys: if key in client_config_map.keys(): _migrate_global_config_field(client_config_map, data, key) for key in data: logging.getLogger().warning(f"Global ConfigVar {key} was not migrated.") errors.extend(client_config_map.validate_model()) if len(errors) == 0: save_to_yml(CLIENT_CONFIG_PATH, client_config_map) global_config_path.unlink() logging.getLogger().info("\nSuccessfully migrated the global config.") else: errors = [f"client_config_map - {e}" for e in errors] logging.getLogger().error(f"The migration of the global config map failed with errors: {errors}") return errors
def test_import_incomplete_config_file_success( self, status_check_all_mock: AsyncMock, get_strategy_pydantic_config_cls: MagicMock): strategy_name = "perpetual_market_making" strategy_file_name = f"{strategy_name}.yml" status_check_all_mock.return_value = True dummy_strategy_config_cls = self.build_dummy_strategy_config_cls( strategy_name) get_strategy_pydantic_config_cls.return_value = dummy_strategy_config_cls cm = ClientConfigAdapter( dummy_strategy_config_cls(no_default="some value")) with TemporaryDirectory() as d: d = Path(d) import_command.STRATEGIES_CONF_DIR_PATH = d temp_file_name = d / strategy_file_name cm_yml_str = cm.generate_yml_output_str_with_comments() cm_yml_str = cm_yml_str.replace("\nno_default: some value\n", "") with open(temp_file_name, "w+") as outfile: outfile.write(cm_yml_str) self.async_run_with_timeout( self.app.import_config_file(strategy_file_name)) self.assertEqual(strategy_file_name, self.app.strategy_file_name) self.assertEqual(strategy_name, self.app.strategy_name) self.assertTrue( self.cli_mock_assistant.check_log_called_with( "\nEnter \"start\" to start market making.")) self.assertNotEqual(cm, self.app.strategy_config_map) validation_errors = self.app.strategy_config_map.validate_model() self.assertEqual(1, len(validation_errors)) self.assertEqual("no_default - field required", validation_errors[0])
async def prompt_a_config( self, # type: HummingbotApplication model: ClientConfigAdapter, config: str, input_value=None, assign_default=True, ): config_path = config.split(".") while len(config_path) != 1: sub_model_attr = config_path.pop(0) model = getattr(model, sub_model_attr) config = config_path[0] if input_value is None: prompt = await model.get_client_prompt(config) if prompt is not None: if assign_default: default = model.get_default(config) default = str(default) if default is not None else "" self.app.set_text(default) prompt = f"{prompt} >>> " client_data = model.get_client_data(config) input_value = await self.app.prompt(prompt=prompt, is_password=client_data.is_secure) new_config_value = None if not self.app.to_stop_config and input_value is not None: try: setattr(model, config, input_value) new_config_value = getattr(model, config) except ConfigValidationError as e: self.notify(str(e)) new_config_value = await self.prompt_a_config(model, config) if not self.app.to_stop_config and isinstance(new_config_value, ClientConfigAdapter): await self.prompt_for_model_config(new_config_value)
def _migrate_global_config_field( cm: ClientConfigAdapter, global_config_data: Dict[str, Any], attr: str, cm_attr: Optional[str] = None ): value = global_config_data.pop(attr) cm_attr = cm_attr if cm_attr is not None else attr if value is not None: cm.setattr_no_validation(cm_attr, value)
async def prompt_for_model_config( self, # type: HummingbotApplication config_map: ClientConfigAdapter, ): for key in config_map.keys(): client_data = config_map.get_client_data(key) if ( client_data is not None and (client_data.prompt_on_new or config_map.is_required(key)) ): await self.prompt_a_config(config_map, key) if self.app.to_stop_config: break
def build_config_map(cm: ClientConfigAdapter, cs: Dict): """This routine can be used in the create command, with slight modifications.""" for key in cm.keys(): client_data = cm.get_client_data(key) if client_data is not None and client_data.prompt_on_new: self.assertIsInstance(client_data.prompt(cm), str) if key == "execution_timeframe_model": setattr(cm, key, "daily_between_times") # simulate user input else: setattr(cm, key, cs[key]) new_value = getattr(cm, key) if isinstance(new_value, ClientConfigAdapter): build_config_map(new_value, cs[key])
def setUp(self): self.maxDiff = None self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0, self.start_timestamp, self.end_timestamp) self.market_1: MockPaperExchange = MockPaperExchange( client_config_map=ClientConfigAdapter(ClientConfigMap())) self.market_2: MockPaperExchange = MockPaperExchange( client_config_map=ClientConfigAdapter(ClientConfigMap())) self.market_1.set_balanced_order_book(self.market_1_trading_pairs[0], 1.0, 0.5, 1.5, 0.01, 10) self.market_2.set_balanced_order_book(self.market_2_trading_pairs[0], 1.0, 0.5, 1.5, 0.005, 5) self.market_1.set_balance("COINALPHA", 500) self.market_1.set_balance("WETH", 500) self.market_2.set_balance("COINALPHA", 500) self.market_2.set_balance("ETH", 500) self.market_1.set_quantization_param( QuantizationParams(self.market_1_trading_pairs[0], 5, 5, 5, 5)) self.market_2.set_quantization_param( QuantizationParams(self.market_2_trading_pairs[0], 5, 5, 5, 5)) self.market_trading_pair_tuple_1 = MarketTradingPairTuple( *([self.market_1] + self.market_1_trading_pairs)) self.market_trading_pair_tuple_2 = MarketTradingPairTuple( *([self.market_2] + self.market_2_trading_pairs)) self.market_pair: ArbitrageMarketPair = ArbitrageMarketPair( self.market_trading_pair_tuple_1, self.market_trading_pair_tuple_2) self.logging_options: int = ArbitrageStrategy.OPTION_LOG_ALL self.strategy: ArbitrageStrategy = ArbitrageStrategy() self.strategy.init_params( [self.market_pair], min_profitability=Decimal("0.03"), logging_options=self.logging_options, secondary_to_primary_quote_conversion_rate=Decimal("0.95")) self.clock.add_iterator(self.market_1) self.clock.add_iterator(self.market_2) self.clock.add_iterator(self.strategy) self.market_1_order_fill_logger: EventLogger = EventLogger() self.market_2_order_fill_logger: EventLogger = EventLogger() self.market_1.add_listener(MarketEvent.OrderFilled, self.market_1_order_fill_logger) self.market_2.add_listener(MarketEvent.OrderFilled, self.market_2_order_fill_logger)
def test_create_paper_trade_market_for_connector_using_generic_tracker( self): paper_exchange = create_paper_trade_market( exchange_name="binance", client_config_map=ClientConfigAdapter(ClientConfigMap()), trading_pairs=["COINALPHA-HBOT"]) self.assertEqual(BinanceAPIOrderBookDataSource, type(paper_exchange.order_book_tracker.data_source)) paper_exchange = create_paper_trade_market( exchange_name="kucoin", client_config_map=ClientConfigAdapter(ClientConfigMap()), trading_pairs=["COINALPHA-HBOT"]) self.assertEqual(KucoinAPIOrderBookDataSource, type(paper_exchange.order_book_tracker.data_source))
def setUp(self): self.clock: Clock = Clock(ClockMode.REALTIME) self.stack: contextlib.ExitStack = contextlib.ExitStack() self.amm_1: MockAMM = MockAMM( name="onion", client_config_map=ClientConfigAdapter(ClientConfigMap())) self.amm_1.set_balance(BASE_ASSET, 500) self.amm_1.set_balance(QUOTE_ASSET, 500) self.market_info_1 = MarketTradingPairTuple(self.amm_1, TRADING_PAIR, BASE_ASSET, QUOTE_ASSET) self.amm_2: MockAMM = MockAMM( name="garlic", client_config_map=ClientConfigAdapter(ClientConfigMap())) self.amm_2.set_balance(BASE_ASSET, 500) self.amm_2.set_balance(QUOTE_ASSET, 500) self.market_info_2 = MarketTradingPairTuple(self.amm_2, TRADING_PAIR, BASE_ASSET, QUOTE_ASSET) # Set some default prices. self.amm_1.set_prices(TRADING_PAIR, True, 101) self.amm_1.set_prices(TRADING_PAIR, False, 100) self.amm_2.set_prices(TRADING_PAIR, True, 105) self.amm_2.set_prices(TRADING_PAIR, False, 104) self.strategy = AmmArbStrategy() self.strategy.init_params( self.market_info_1, self.market_info_2, min_profitability=Decimal("0.01"), order_amount=Decimal("1"), market_1_slippage_buffer=Decimal("0.001"), market_2_slippage_buffer=Decimal("0.002"), ) self.rate_source: FixedRateSource = FixedRateSource() self.strategy.rate_source = self.rate_source self.clock.add_iterator(self.amm_1) self.clock.add_iterator(self.amm_2) self.clock.add_iterator(self.strategy) self.market_order_fill_logger: EventLogger = EventLogger() self.amm_1.add_listener(MarketEvent.OrderFilled, self.market_order_fill_logger) self.amm_2.add_listener(MarketEvent.OrderFilled, self.market_order_fill_logger) self.rate_source.add_rate("ETH-USDT", Decimal(3000)) self.stack.enter_context(self.clock) self.stack.enter_context(patch( "hummingbot.client.config.trade_fee_schema_loader.TradeFeeSchemaLoader.configured_schema_for_exchange", return_value=TradeFeeSchema() )) self.clock_task: asyncio.Task = safe_ensure_future(self.clock.run())
def create_market(trading_pairs: List[str], mid_price, balances: Dict[str, int]) -> \ (MockPaperExchange, Dict[str, MarketTradingPairTuple]): """ Create a BacktestMarket and marketinfo dictionary to be used by the liquidity mining strategy """ market: MockPaperExchange = MockPaperExchange( client_config_map=ClientConfigAdapter(ClientConfigMap()) ) market_infos: Dict[str, MarketTradingPairTuple] = {} for trading_pair in trading_pairs: base_asset = trading_pair.split("-")[0] quote_asset = trading_pair.split("-")[1] market.set_balanced_order_book(trading_pair=trading_pair, mid_price=mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) market.set_quantization_param(QuantizationParams(trading_pair, 6, 6, 6, 6)) market_infos[trading_pair] = MarketTradingPairTuple(market, trading_pair, base_asset, quote_asset) for asset, value in balances.items(): market.set_balance(asset, value) return market, market_infos
def setUpClass(cls): cls.ev_loop = asyncio.get_event_loop() cls.trading_pair = "COINALPHA-HBOT" cls.limit_orders: List[LimitOrder] = [ LimitOrder(client_order_id=f"LIMIT//-{i}-{int(time.time()*1e6)}", trading_pair=cls.trading_pair, is_buy=True if i % 2 == 0 else False, base_currency=cls.trading_pair.split("-")[0], quote_currency=cls.trading_pair.split("-")[1], price=Decimal(f"{100 - i}") if i % 2 == 0 else Decimal(f"{100 + i}"), quantity=Decimal(f"{10 * (i + 1)}"), creation_timestamp=int(time.time() * 1e6)) for i in range(20) ] cls.market_orders: List[MarketOrder] = [ MarketOrder(order_id=f"MARKET//-{i}-{int(time.time()*1e3)}", trading_pair=cls.trading_pair, is_buy=True if i % 2 == 0 else False, base_asset=cls.trading_pair.split("-")[0], quote_asset=cls.trading_pair.split("-")[1], amount=float(f"{10 * (i + 1)}"), timestamp=time.time()) for i in range(20) ] cls.market: MockPaperExchange = MockPaperExchange( client_config_map=ClientConfigAdapter(ClientConfigMap())) cls.market_info: MarketTradingPairTuple = MarketTradingPairTuple( cls.market, cls.trading_pair, *cls.trading_pair.split("-"))
def setUp(self) -> None: np.random.seed(self.INITIAL_RANDOM_SEED) trade_fee_schema = TradeFeeSchema( maker_percent_fee_decimal=Decimal("0.25"), taker_percent_fee_decimal=Decimal("0.25")) client_config_map = ClientConfigAdapter(ClientConfigMap()) self.market: MockPaperExchange = MockPaperExchange( client_config_map, trade_fee_schema) self.market_info: MarketTradingPairTuple = MarketTradingPairTuple( self.market, self.trading_pair, *self.trading_pair.split("-")) self.market.set_balanced_order_book(trading_pair=self.trading_pair, mid_price=self.initial_mid_price, min_price=1, max_price=200, price_step_size=1, volume_step_size=10) self.market.set_balance("COINALPHA", 1) self.market.set_balance("HBOT", 500) self.market.set_quantization_param( QuantizationParams(self.trading_pair.split("-")[0], 6, 6, 6, 6)) self.price_delegate = OrderBookAssetPriceDelegate( self.market_info.market, self.trading_pair) self.indicator = TradingIntensityIndicator( order_book=self.market_info.order_book, price_delegate=self.price_delegate, sampling_length=self.BUFFER_LENGTH)
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
def setUp(self) -> None: super().setUp() self.log_records = [] self.listening_task = None self.mocking_assistant = NetworkMockingAssistant() client_config_map = ClientConfigAdapter(ClientConfigMap()) self.connector = OkxExchange( client_config_map=client_config_map, okx_api_key="", okx_secret_key="", okx_passphrase="", trading_pairs=[self.trading_pair], trading_required=False, ) self.data_source = OkxAPIOrderBookDataSource( trading_pairs=[self.trading_pair], connector=self.connector, api_factory=self.connector._web_assistants_factory) self.data_source.logger().setLevel(1) self.data_source.logger().addHandler(self) self.resume_test_event = asyncio.Event() self.connector._set_trading_pair_symbol_map( bidict( {f"{self.base_asset}-{self.quote_asset}": self.trading_pair}))
def setUp(self): self.log_records = [] self.start: pd.Timestamp = pd.Timestamp("2019-01-01", tz="UTC") self.end: pd.Timestamp = pd.Timestamp("2019-01-01 01:00:00", tz="UTC") self.start_timestamp: float = self.start.timestamp() self.end_timestamp: float = self.end.timestamp() self.connector_name: str = "mock_paper_exchange" self.trading_pair: str = "HBOT-USDT" self.base_asset, self.quote_asset = self.trading_pair.split("-") self.base_balance: int = 500 self.quote_balance: int = 5000 self.initial_mid_price: int = 100 self.clock_tick_size = 1 self.clock: Clock = Clock(ClockMode.BACKTEST, self.clock_tick_size, self.start_timestamp, self.end_timestamp) self.connector: MockPaperExchange = MockPaperExchange( client_config_map=ClientConfigAdapter(ClientConfigMap())) self.connector.set_balanced_order_book(trading_pair=self.trading_pair, mid_price=100, min_price=50, max_price=150, price_step_size=1, volume_step_size=10) self.connector.set_balance(self.base_asset, self.base_balance) self.connector.set_balance(self.quote_asset, self.quote_balance) self.connector.set_quantization_param( QuantizationParams(self.trading_pair, 6, 6, 6, 6)) self.clock.add_iterator(self.connector) ScriptStrategyBase.markets = {self.connector_name: {self.trading_pair}} self.strategy = ScriptStrategyBase( {self.connector_name: self.connector}) self.strategy.logger().setLevel(1) self.strategy.logger().addHandler(self)
def setUp(self) -> None: super().setUp() self.log_records = [] self.listening_task = None self.mocking_assistant = NetworkMockingAssistant() self.client_config_map = ClientConfigAdapter(ClientConfigMap()) self.connector = BitmartExchange( client_config_map=self.client_config_map, bitmart_api_key="", bitmart_secret_key="", bitmart_memo="", trading_pairs=[self.trading_pair], trading_required=False, ) self.data_source = BitmartAPIOrderBookDataSource( trading_pairs=[self.trading_pair], connector=self.connector, api_factory=self.connector._web_assistants_factory) self.data_source.logger().setLevel(1) self.data_source.logger().addHandler(self) self.connector._set_trading_pair_symbol_map( bidict({self.ex_trading_pair: self.trading_pair}))
def test_import_config_file_success( self, status_check_all_mock: AsyncMock, get_strategy_pydantic_config_cls: MagicMock): strategy_name = "perpetual_market_making" strategy_file_name = f"{strategy_name}.yml" status_check_all_mock.return_value = True dummy_strategy_config_cls = self.build_dummy_strategy_config_cls( strategy_name) get_strategy_pydantic_config_cls.return_value = dummy_strategy_config_cls cm = ClientConfigAdapter( dummy_strategy_config_cls(no_default="some value")) with TemporaryDirectory() as d: d = Path(d) import_command.STRATEGIES_CONF_DIR_PATH = d temp_file_name = d / strategy_file_name save_to_yml(temp_file_name, cm) self.async_run_with_timeout( self.app.import_config_file(strategy_file_name)) self.assertEqual(strategy_file_name, self.app.strategy_file_name) self.assertEqual(strategy_name, self.app.strategy_name) self.assertTrue( self.cli_mock_assistant.check_log_called_with( "\nEnter \"start\" to start market making.")) self.assertEqual(cm, self.app.strategy_config_map)
def setUp(self) -> None: super().setUp() self.log_records = [] self.async_task = None self.mocking_assistant = NetworkMockingAssistant() client_config_map = ClientConfigAdapter(ClientConfigMap()) self.connector = KucoinExchange(client_config_map=client_config_map, kucoin_api_key="", kucoin_passphrase="", kucoin_secret_key="", trading_pairs=[], trading_required=False) self.ob_data_source = KucoinAPIOrderBookDataSource( trading_pairs=[self.trading_pair], connector=self.connector, api_factory=self.connector._web_assistants_factory) self.ob_data_source.logger().setLevel(1) self.ob_data_source.logger().addHandler(self) self.connector._set_trading_pair_symbol_map( bidict({self.trading_pair: self.trading_pair}))
def store_binance_config(self) -> ClientConfigAdapter: config_map = ClientConfigAdapter( BinanceConfigMap(binance_api_key=self.api_key, binance_api_secret=self.api_secret) ) file_path = get_connector_config_yml_path(self.connector) save_to_yml(file_path, config_map) return config_map
def test_connector_config_maps(self): connector_exceptions = [ "mock_paper_exchange", "mock_pure_python_paper_exchange", "paper_trade", "celo" ] type_dirs = [ cast(DirEntry, f) for f in scandir(f"{root_path() / 'hummingbot' / 'connector'}") if f.is_dir() ] for type_dir in type_dirs: connector_dirs = [ cast(DirEntry, f) for f in scandir(type_dir.path) if f.is_dir() and exists(join(f.path, "__init__.py")) ] for connector_dir in connector_dirs: if connector_dir.name.startswith( "_") or connector_dir.name in connector_exceptions: continue util_module_path: str = ( f"hummingbot.connector.{type_dir.name}.{connector_dir.name}.{connector_dir.name}_utils" ) util_module = importlib.import_module(util_module_path) connector_config = getattr(util_module, "KEYS") self.assertIsInstance(connector_config, BaseConnectorConfigMap) for el in ClientConfigAdapter(connector_config).traverse(): if el.attr == "connector": self.assertEqual(el.value, connector_dir.name) elif el.client_field_data.is_secure: self.assertEqual(el.type_, SecretStr) else: self.assertEqual(el.type_, str)
def test_show_ticker(self, notify_mock): self.client_config_map.db_mode = DBSqliteMode() captures = [] notify_mock.side_effect = lambda s: captures.append(s) exchange_name = "paper" exchange = MockPaperExchange( client_config_map=ClientConfigAdapter(ClientConfigMap())) self.app.markets[exchange_name] = exchange trading_pair = "BTC-USDT" exchange.set_balanced_order_book( trading_pair, mid_price=10, min_price=8.5, max_price=11.5, price_step_size=1, volume_step_size=1, ) self.async_run_with_timeout( self.app.show_ticker(exchange=exchange_name, live=False)) self.assertEqual(1, len(captures)) df_str_expected = ( " Market: mock_paper_exchange" "\n+------------+------------+-------------+--------------+" "\n| Best Bid | Best Ask | Mid Price | Last Trade |" "\n|------------+------------+-------------+--------------|" "\n| 9.5 | 10.5 | 10 | nan |" "\n+------------+------------+-------------+--------------+") self.assertEqual(df_str_expected, captures[0])
def migrate_xemm_confs(conf, new_path) -> List[str]: if "active_order_canceling" in conf: if conf["active_order_canceling"]: conf["order_refresh_mode"] = {} else: conf["order_refresh_mode"] = { "cancel_order_threshold": conf["cancel_order_threshold"], "limit_order_min_expiration": conf["limit_order_min_expiration"] } conf.pop("active_order_canceling") conf.pop("cancel_order_threshold") conf.pop("limit_order_min_expiration") if "use_oracle_conversion_rate" in conf: if conf["use_oracle_conversion_rate"]: conf["conversion_rate_mode"] = {} else: conf["conversion_rate_mode"] = { "taker_to_maker_base_conversion_rate": conf["taker_to_maker_base_conversion_rate"], "taker_to_maker_quote_conversion_rate": conf["taker_to_maker_quote_conversion_rate"] } conf.pop("use_oracle_conversion_rate") conf.pop("taker_to_maker_base_conversion_rate") conf.pop("taker_to_maker_quote_conversion_rate") if "template_version" in conf: conf.pop("template_version") try: config_map = ClientConfigAdapter(CrossExchangeMarketMakingConfigMap(**conf)) save_to_yml(new_path, config_map) errors = [] except Exception as e: logging.getLogger().error(str(e)) errors = [str(e)] return errors
def test_get_last_price(self, mock_api, connector_creator_mock): client_config_map = ClientConfigAdapter(ClientConfigMap()) connector = BinanceExchange( client_config_map, binance_api_key="", binance_api_secret="", trading_pairs=[], trading_required=False) connector._set_trading_pair_symbol_map(bidict({f"{self.binance_ex_trading_pair}": self.trading_pair})) connector_creator_mock.return_value = connector url = web_utils.public_rest_url(path_url=CONSTANTS.TICKER_PRICE_CHANGE_PATH_URL) regex_url = re.compile(f"^{url}".replace(".", r"\.").replace("?", r"\?")) mock_response: Dict[str, Any] = { # truncated response "symbol": self.binance_ex_trading_pair, "lastPrice": "1", } mock_api.get(regex_url, body=ujson.dumps(mock_response)) result = self.async_run_with_timeout(market_price.get_last_price( exchange="binance", trading_pair=self.trading_pair, )) self.assertEqual(result, Decimal("1.0"))
def setUpClass(cls) -> None: super().setUpClass() GatewayHttpClient.__instance = None cls._db_path = realpath( join(__file__, "../fixtures/gateway_evm_amm_fixture.db")) cls._http_player = HttpPlayer(cls._db_path) cls._clock: Clock = Clock(ClockMode.REALTIME) cls._client_config_map = ClientConfigAdapter(ClientConfigMap()) cls._connector: GatewayEVMAMM = GatewayEVMAMM( client_config_map=cls._client_config_map, connector_name="uniswap", chain="ethereum", network="ropsten", wallet_address="0x5821715133bB451bDE2d5BC6a4cE3430a4fdAF92", trading_pairs=["DAI-WETH"], trading_required=True) cls._clock.add_iterator(cls._connector) cls._patch_stack = ExitStack() cls._patch_stack.enter_context(cls._http_player.patch_aiohttp_client()) cls._patch_stack.enter_context( patch( "hummingbot.core.gateway.gateway_http_client.GatewayHttpClient._http_client", return_value=ClientSession())) cls._patch_stack.enter_context(cls._clock) GatewayHttpClient.get_instance(client_config_map=cls._client_config_map ).base_url = "https://localhost:5000" ev_loop.run_until_complete(cls.wait_til_ready())
def setUp(self): self.maxDiff = None self.clock: Clock = Clock(ClockMode.BACKTEST, 1.0, self.start_timestamp, self.end_timestamp) self.market: MockPaperExchange = MockPaperExchange( client_config_map=ClientConfigAdapter(ClientConfigMap())) self.market.set_balanced_order_book(self.trading_pair, 10, 5, 15, 0.1, 1) self.market.set_balance(self.base_asset, 500) self.market.set_balance(self.quote_asset, 500) self.market.set_quantization_param( QuantizationParams(self.trading_pair, 5, 5, 5, 5)) self.market_info = MarketTradingPairTuple(self.market, self.trading_pair, self.base_asset, self.quote_asset) self.logging_options: int = CeloArbStrategy.OPTION_LOG_ALL self.strategy = CeloArbStrategy() self.strategy.init_params(self.market_info, min_profitability=Decimal("0.01"), order_amount=Decimal("1"), celo_slippage_buffer=Decimal("0.001"), logging_options=self.logging_options, hb_app_notification=False, mock_celo_cli_mode=True) self.clock.add_iterator(self.market) self.clock.add_iterator(self.strategy) self.market_order_fill_logger: EventLogger = EventLogger() self.market.add_listener(MarketEvent.OrderFilled, self.market_order_fill_logger) CeloCLI.unlock_account(TEST_ADDRESS, TEST_PASSWORD)
def setUp(self) -> None: super().setUp() self.log_records = [] self.listening_task: Optional[asyncio.Task] = None self.mocking_assistant = NetworkMockingAssistant() self.throttler = AsyncThrottler(CONSTANTS.RATE_LIMITS) self.mock_time_provider = MagicMock() self.mock_time_provider.time.return_value = 1000 self.auth = KucoinAuth( self.api_key, self.api_passphrase, self.api_secret_key, time_provider=self.mock_time_provider) client_config_map = ClientConfigAdapter(ClientConfigMap()) self.connector = KucoinExchange( client_config_map=client_config_map, kucoin_api_key="", kucoin_passphrase="", kucoin_secret_key="", trading_pairs=[], trading_required=False) self.data_source = KucoinAPIUserStreamDataSource( auth=self.auth, trading_pairs=[self.trading_pair], connector=self.connector, api_factory=self.connector._web_assistants_factory) self.data_source.logger().setLevel(1) self.data_source.logger().addHandler(self)
def setUpClass(cls) -> None: super().setUpClass() cls._db_path = realpath( join(__file__, "../fixtures/gateway_evm_amm_lp_fixture.db")) cls._http_player = HttpPlayer(cls._db_path) cls._clock: Clock = Clock(ClockMode.REALTIME) cls._client_config_map = ClientConfigAdapter(ClientConfigMap()) cls._connector: GatewayEVMAMMLP = GatewayEVMAMMLP( client_config_map=cls._client_config_map, connector_name="uniswapLP", chain="ethereum", network="kovan", wallet_address="0xefb7be8631d154d4c0ad8676fec0897b2894fe8f", trading_pairs=["COIN1-COIN3"], trading_required=True) cls._clock.add_iterator(cls._connector) cls._patch_stack = ExitStack() cls._patch_stack.enter_context(cls._http_player.patch_aiohttp_client()) cls._patch_stack.enter_context( patch( "hummingbot.core.gateway.gateway_http_client.GatewayHttpClient._http_client", return_value=ClientSession())) cls._patch_stack.enter_context(cls._clock) GatewayHttpClient.get_instance(client_config_map=cls._client_config_map ).base_url = "https://localhost:5000" ev_loop.run_until_complete(cls.wait_til_ready())