def simulate_order_book_widening(order_book: OrderBook, top_bid: float, top_ask: float):
bid_diffs: List[OrderBookRow] = []
ask_diffs: List[OrderBookRow] = []
update_id: int = order_book.last_diff_uid + 1
for row in order_book.bid_entries():
if row.price > top_bid:
bid_diffs.append(OrderBookRow(row.price, 0, update_id))
else:
break
for row in order_book.ask_entries():
if row.price < top_ask:
ask_diffs.append(OrderBookRow(row.price, 0, update_id))
else:
break
order_book.apply_diffs(bid_diffs, ask_diffs, update_id)
def __init__(self, trading_pairs: Optional[List[str]] = None):
super().__init__()
self._trading_pairs: Optional[List[str]] = trading_pairs
self._order_book_create_function = lambda: OrderBook()
self.trading_pair_id_conversion_dict: Dict[str, int] = {}
def __init__(self, trading_pairs: List[str] = None, rest_api_url="", websocket_url="", token_configuration=None):
super().__init__(trading_pairs)
self.REST_URL = rest_api_url
self.WS_URL = websocket_url
self._get_tracking_pair_done_event: asyncio.Event = asyncio.Event()
self.order_book_create_function = lambda: OrderBook()
self.token_configuration: LoopringAPITokenConfigurationDataSource = token_configuration
def __init__(self,
trading_pairs: List[str] = None,
domain: str = CONSTANTS.DOMAIN,
throttler: Optional[AsyncThrottler] = None):
super().__init__(trading_pairs)
self._order_book_create_function = lambda: OrderBook()
self._domain = domain
self._throttler = throttler or self._get_throttler_instance()
def __init__(self,
base_url: str,
stream_url: str,
trading_pairs: List[str] = None):
super().__init__(trading_pairs)
self._order_book_create_function = lambda: OrderBook()
self._base_url = base_url
self._stream_url = stream_url + "/stream"
self._domain = "binance_perpetual" if base_url == PERPETUAL_BASE_URL else "binance_perpetual_testnet"
def __init__(self,
trading_pairs: List[str] = None,
domain: str = "binance_perpetual"):
super().__init__(trading_pairs)
self._order_book_create_function = lambda: OrderBook()
self._base_url = TESTNET_BASE_URL if domain == "binance_perpetual_testnet" else PERPETUAL_BASE_URL
self._stream_url = TESTNET_STREAM_URL if domain == "binance_perpetual_testnet" else DIFF_STREAM_URL
self._stream_url += "/stream"
self._domain = domain
def __init__(self,
throttler: Optional[AsyncThrottler] = None,
trading_pairs: List[str] = None,
api_factory: Optional[WebAssistantsFactory] = None):
super().__init__(trading_pairs)
self._api_factory = api_factory or build_api_factory()
self._rest_assistant = None
self._ws_assistant = None
self._order_book_create_function = lambda: OrderBook()
self._throttler = throttler or self._get_throttler_instance()
def __init__(self,
trading_pairs: List[str],
domain: str = CONSTANTS.DEFAULT_DOMAIN,
api_factory: Optional[WebAssistantsFactory] = None,
throttler: Optional[AsyncThrottler] = None):
super().__init__(trading_pairs)
self._domain = domain
self._throttler = throttler
self._api_factory = api_factory or web_utils.build_api_factory()
self._order_book_create_function = lambda: OrderBook()
self._message_queue: Dict[str,
asyncio.Queue] = defaultdict(asyncio.Queue)
def __init__(
self,
throttler: Optional[AsyncThrottler] = None,
trading_pairs: Optional[List[str]] = None,
auth: Optional[KucoinAuth] = None,
):
super().__init__(trading_pairs)
self._throttler = throttler or self._get_throttler_instance()
self._auth = auth
self._order_book_create_function = lambda: OrderBook()
self._tasks: DefaultDict[StreamType, Dict[
int, KucoinAPIOrderBookDataSource.TaskEntry]] = defaultdict(dict)
def __init__(self,
trading_pairs: List[str],
domain="com",
api_factory: Optional[WebAssistantsFactory] = None,
throttler: Optional[AsyncThrottler] = None):
super().__init__(trading_pairs)
self._order_book_create_function = lambda: OrderBook()
self._domain = domain
self._throttler = throttler or self._get_throttler_instance()
self._api_factory = api_factory or build_api_factory()
self._rest_assistant: Optional[RESTAssistant] = None
self._ws_assistant: Optional[WSAssistant] = None
self._message_queue: Dict[str,
asyncio.Queue] = defaultdict(asyncio.Queue)
def __init__(
self,
trading_pairs: List[str] = None,
domain: str = CONSTANTS.DOMAIN,
throttler: Optional[AsyncThrottler] = None,
api_factory: Optional[WebAssistantsFactory] = None,
):
super().__init__(trading_pairs)
self._api_factory: WebAssistantsFactory = api_factory or utils.build_api_factory()
self._ws_assistant: Optional[WSAssistant] = None
self._order_book_create_function = lambda: OrderBook()
self._domain = domain
self._throttler = throttler or self._get_throttler_instance()
self._funding_info: Dict[str, FundingInfo] = {}
self._message_queue: Dict[int, asyncio.Queue] = defaultdict(asyncio.Queue)
def test_calculate_trading_intensity_deterministic(self):
def curve_fn(
t_, a_, b_
): # see curve fit in `TradingIntensityIndicator.c_estimate_intensity`
return a_ * np.exp(-b_ * t_)
last_price = 1
trade_price_levels = [2, 3, 4, 5]
a = 2
b = 0.1
ts = [curve_fn(p - last_price, a, b) for p in trade_price_levels]
timestamp = self.start_timestamp
trading_intensity_indicator = TradingIntensityIndicator(
OrderBook(), self.price_delegate, 1)
trading_intensity_indicator.last_quotes = [{
"timestamp": timestamp,
"price": last_price
}]
timestamp += 1
for p, t in zip(trade_price_levels, ts):
new_trade = OrderBookTradeEvent(
trading_pair="COINALPHAHBOT",
timestamp=timestamp,
price=p,
amount=t,
type=TradeType.SELL,
)
trading_intensity_indicator.register_trade(new_trade)
trading_intensity_indicator.calculate(timestamp)
alpha, kappa = trading_intensity_indicator.current_value
self.assertAlmostEqual(a, alpha, 10)
self.assertAlmostEqual(b, kappa, 10)
def __init__(self, trading_pairs: List[str]):
self._trading_pairs: List[str] = trading_pairs
self._order_book_create_function = lambda: OrderBook()
def __init__(self, trading_pairs: List[str]):
super().__init__(trading_pairs)
self._order_book_create_function = lambda: OrderBook()
self._tasks: DefaultDict[StreamType, Dict[int, KucoinAPIOrderBookDataSource.TaskEntry]] = defaultdict(dict)
def __init__(self):
self._order_book_create_function = lambda: OrderBook()
def setUpClass(cls):
cls.order_book_dex = OrderBook(dex=True)
cls.order_book_cex = OrderBook(dex=False)
def __init__(self, trading_pairs: List[str]):
super().__init__(trading_pairs)
self._order_book_create_function = lambda: OrderBook()
def __init__(self, trading_pairs: Optional[List[str]] = None):
super().__init__()
self._trading_pairs: Optional[List[str]] = trading_pairs
self._order_book_create_function = lambda: OrderBook()
def __init__(self, symbols: Optional[List[str]] = None):
super().__init__()
self._symbols: Optional[List[str]] = symbols
self._order_book_create_function = lambda: OrderBook()
def __init__(self, trading_pairs: List[str]):
super().__init__(trading_pairs)
self._order_book_create_function = lambda: OrderBook()
self.trading_pair_id_conversion_dict: Dict[str, int] = {}
