code stringlengths 17 6.64M |
|---|
@dataclass
class CancelOrderMsg(OrderMsg):
order: LimitOrder
tag: str
metadata: dict
|
@dataclass
class PartialCancelOrderMsg(OrderMsg):
order: LimitOrder
quantity: int
tag: str
metadata: dict
|
@dataclass
class ModifyOrderMsg(OrderMsg):
old_order: LimitOrder
new_order: LimitOrder
|
@dataclass
class ReplaceOrderMsg(OrderMsg):
agent_id: int
old_order: LimitOrder
new_order: LimitOrder
|
@dataclass
class OrderBookMsg(Message, ABC):
pass
|
@dataclass
class OrderAcceptedMsg(OrderBookMsg):
order: LimitOrder
|
@dataclass
class OrderExecutedMsg(OrderBookMsg):
order: Order
|
@dataclass
class OrderCancelledMsg(OrderBookMsg):
order: LimitOrder
|
@dataclass
class OrderPartialCancelledMsg(OrderBookMsg):
new_order: LimitOrder
|
@dataclass
class OrderModifiedMsg(OrderBookMsg):
new_order: LimitOrder
|
@dataclass
class OrderReplacedMsg(OrderBookMsg):
old_order: LimitOrder
new_order: LimitOrder
|
@dataclass
class QueryMsg(Message, ABC):
symbol: str
|
@dataclass
class QueryResponseMsg(Message, ABC):
symbol: str
mkt_closed: bool
|
@dataclass
class QueryLastTradeMsg(QueryMsg):
pass
|
@dataclass
class QueryLastTradeResponseMsg(QueryResponseMsg):
last_trade: Optional[int]
|
@dataclass
class QuerySpreadMsg(QueryMsg):
depth: int
|
@dataclass
class QuerySpreadResponseMsg(QueryResponseMsg):
depth: int
bids: List[Tuple[(int, int)]]
asks: List[Tuple[(int, int)]]
last_trade: Optional[int]
|
@dataclass
class QueryOrderStreamMsg(QueryMsg):
length: int
|
@dataclass
class QueryOrderStreamResponseMsg(QueryResponseMsg):
length: int
orders: List[Dict[(str, Any)]]
|
@dataclass
class QueryTransactedVolMsg(QueryMsg):
lookback_period: str
|
@dataclass
class QueryTransactedVolResponseMsg(QueryResponseMsg):
bid_volume: int
ask_volume: int
|
class OrderSizeModel():
def __init__(self) -> None:
self.model = GeneralMixtureModel.from_json(json.dumps(order_size))
def sample(self, random_state: np.random.RandomState) -> float:
return round(self.model.sample(random_state=random_state))
|
class MeanRevertingOracle(Oracle):
'The MeanRevertingOracle requires three parameters: a mean fundamental value,\n a mean reversion coefficient, and a shock variance. It constructs and retains\n a fundamental value time series for each requested symbol, and provides noisy\n observations of those values upon agent request. The expectation is that\n agents using such an oracle will know the mean-reverting equation and all\n relevant parameters, but will not know the random shocks applied to the\n sequence at each time step.\n\n Historical dates are effectively meaningless to this oracle. It is driven by\n the numpy random number seed contained within the experimental config file.\n This oracle uses the nanoseconds portion of the current simulation time as\n discrete "time steps". A suggestion: to keep wallclock runtime reasonable,\n have the agents operate for only ~1000 nanoseconds, but interpret nanoseconds\n as seconds or minutes.'
def __init__(self, mkt_open: NanosecondTime, mkt_close: NanosecondTime, symbols: Dict[(str, Dict[(str, Any)])]) -> None:
self.mkt_open: NanosecondTime = mkt_open
self.mkt_close: NanosecondTime = mkt_close
self.symbols: Dict[(str, Dict[(str, Any)])] = symbols
self.r: Dict[(str, pd.Series)] = {}
then = dt.datetime.now()
for symbol in symbols:
s = symbols[symbol]
logger.debug('MeanRevertingOracle computing fundamental value series for {}', symbol)
self.r[symbol] = self.generate_fundamental_value_series(symbol=symbol, **s)
now = dt.datetime.now()
logger.debug('MeanRevertingOracle initialized for symbols {}', symbols)
logger.debug('MeanRevertingOracle initialization took {}', (now - then))
def generate_fundamental_value_series(self, symbol: str, r_bar: int, kappa: float, sigma_s: float) -> pd.Series:
"Generates the fundamental value series for a single stock symbol.\n\n Arguments:\n symbol: The symbold to calculate the fundamental value series for.\n r_bar: The mean fundamental value.\n kappa: The mean reversion coefficient.\n sigma_s: The shock variance. (Note: NOT STANDARD DEVIATION)\n\n Because the oracle uses the global np.random PRNG to create the\n fundamental value series, it is important to create the oracle BEFORE\n the agents. In this way the addition of a new agent will not affect the\n sequence created. (Observations using the oracle will use an agent's\n PRNG and thus not cause a problem.)\n "
sigma_s = sqrt(sigma_s)
date_range = pd.date_range(self.mkt_open, self.mkt_close, closed='left', freq='N')
s = pd.Series(index=date_range)
r = np.zeros(len(s.index))
r[0] = r_bar
shock = np.random.normal(scale=sigma_s, size=r.shape[0])
for t in range(1, r.shape[0]):
r[t] = max(0, (((kappa * r_bar) + ((1 - kappa) * r[(t - 1)])) + shock[t]))
s[:] = np.round(r)
return s.astype(int)
def get_daily_open_price(self, symbol: str, mkt_open: NanosecondTime, cents: bool=True) -> int:
'Return the daily open price for the symbol given.\n\n In the case of the MeanRevertingOracle, this will simply be the first\n fundamental value, which is also the fundamental mean. We will use the\n mkt_open time as given, however, even if it disagrees with this.\n '
if ((mkt_open is not None) and (self.mkt_open is None)):
self.mkt_open = mkt_open
logger.debug('Oracle: client requested {symbol} at market open: {}', self.mkt_open)
open_price = self.r[symbol].loc[self.mkt_open]
logger.debug('Oracle: market open price was was {}', open_price)
return open_price
def observe_price(self, symbol: str, current_time: NanosecondTime, random_state: np.random.RandomState, sigma_n: int=1000) -> int:
'Return a noisy observation of the current fundamental value.\n\n While the fundamental value for a given equity at a given time step does\n not change, multiple agents observing that value will receive different\n observations.\n\n Only the Exchange or other privileged agents should use noisy=False.\n\n sigma_n is experimental observation variance. NOTE: NOT STANDARD DEVIATION.\n\n Each agent must pass its RandomState object to ``observe_price``. This\n ensures that each agent will receive the same answers across multiple\n same-seed simulations even if a new agent has been added to the experiment.\n '
if (current_time >= self.mkt_close):
r_t = self.r[symbol].loc[(self.mkt_close - 1)]
else:
r_t = self.r[symbol].loc[current_time]
if (sigma_n == 0):
obs = r_t
else:
obs = int(round(random_state.normal(loc=r_t, scale=sqrt(sigma_n))))
logger.debug('Oracle: current fundamental value is {} at {}', r_t, current_time)
logger.debug('Oracle: giving client value observation {}', obs)
return obs
|
class Oracle():
def get_daily_open_price(self, symbol: str, mkt_open: NanosecondTime, cents: bool=True) -> int:
raise NotImplementedError
|
class SparseMeanRevertingOracle(MeanRevertingOracle):
'The SparseMeanRevertingOracle produces a fundamental value time series for\n each requested symbol, and provides noisy observations of the fundamental\n value upon agent request. This "sparse discrete" fundamental uses a\n combination of two processes to produce relatively realistic synthetic\n "values": a continuous mean-reverting Ornstein-Uhlenbeck process plus\n periodic "megashocks" which arrive following a Poisson process and have\n magnitude drawn from a bimodal normal distribution (overall mean zero,\n but with modes well away from zero). This is necessary because OU itself\n is a single noisy return to the mean (from a perturbed initial state)\n that does not then depart the mean except in terms of minor "noise".\n\n Historical dates are effectively meaningless to this oracle. It is driven by\n the numpy random number seed contained within the experimental config file.\n This oracle uses the nanoseconds portion of the current simulation time as\n discrete "time steps".\n\n This version of the MeanRevertingOracle expects agent activity to be spread\n across a large amount of time, with relatively sparse activity. That is,\n agents each acting at realistic "retail" intervals, on the order of seconds\n or minutes, spread out across the day.\n '
def __init__(self, mkt_open: NanosecondTime, mkt_close: NanosecondTime, symbols: Dict[(str, Dict[(str, Any)])]) -> None:
self.mkt_open: NanosecondTime = mkt_open
self.mkt_close: NanosecondTime = mkt_close
self.symbols: Dict[(str, Dict[(str, Any)])] = symbols
self.f_log: Dict[(str, List[Dict[(str, Any)]])] = {}
self.r: Dict[(str, pd.Series)] = {}
self.megashocks: Dict[(str, List[Dict[(str, Any)]])] = {}
then = dt.datetime.now()
for symbol in symbols:
s = symbols[symbol]
logger.debug('SparseMeanRevertingOracle computing initial fundamental value for {}'.format(symbol))
self.r[symbol] = (mkt_open, s['r_bar'])
self.f_log[symbol] = [{'FundamentalTime': mkt_open, 'FundamentalValue': s['r_bar']}]
ms_time_delta = np.random.exponential(scale=(1.0 / s['megashock_lambda_a']))
mst = (self.mkt_open + ms_time_delta)
msv = s['random_state'].normal(loc=s['megashock_mean'], scale=sqrt(s['megashock_var']))
msv = (msv if (s['random_state'].randint(2) == 0) else (- msv))
self.megashocks[symbol] = [{'MegashockTime': mst, 'MegashockValue': msv}]
now = dt.datetime.now()
logger.debug('SparseMeanRevertingOracle initialized for symbols {}'.format(symbols))
logger.debug('SparseMeanRevertingOracle initialization took {}'.format((now - then)))
def compute_fundamental_at_timestamp(self, ts: NanosecondTime, v_adj, symbol: str, pt: NanosecondTime, pv) -> int:
'\n Arguments:\n ts: A requested timestamp to which we should advance the fundamental.\n v_adj: A value adjustment to apply after advancing time (must pass zero if none).\n symbol: A symbol for which to advance time.\n pt: A previous timestamp.\n pv: A previous fundamental.\n\n Returns:\n The new value.\n\n The last two parameters should relate to the most recent time this method was invoked.\n\n As a side effect, it updates the log of computed fundamental values.\n '
s = self.symbols[symbol]
d = (ts - pt)
mu = s['r_bar']
gamma = s['kappa']
theta = s['fund_vol']
v = s['random_state'].normal(loc=(mu + ((pv - mu) * exp(((- gamma) * d)))), scale=sqrt((((theta ** 2) / (2 * gamma)) * (1 - exp((((- 2) * gamma) * d))))))
v += v_adj
v = max(0, v)
v = int(round(v))
self.r[symbol] = (ts, v)
self.f_log[symbol].append({'FundamentalTime': ts, 'FundamentalValue': v})
return v
def advance_fundamental_value_series(self, current_time: NanosecondTime, symbol: str) -> int:
'This method advances the fundamental value series for a single stock symbol,\n using the OU process. It may proceed in several steps due to our periodic\n application of "megashocks" to push the stock price around, simulating\n exogenous forces.'
s = self.symbols[symbol]
(pt, pv) = self.r[symbol]
if (current_time <= pt):
return pv
mst = self.megashocks[symbol][(- 1)]['MegashockTime']
msv = self.megashocks[symbol][(- 1)]['MegashockValue']
while (mst < current_time):
v = self.compute_fundamental_at_timestamp(mst, msv, symbol, pt, pv)
(pt, pv) = (mst, v)
mst = (pt + int(np.random.exponential(scale=(1.0 / s['megashock_lambda_a']))))
msv = s['random_state'].normal(loc=s['megashock_mean'], scale=sqrt(s['megashock_var']))
msv = (msv if (s['random_state'].randint(2) == 0) else (- msv))
self.megashocks[symbol].append({'MegashockTime': mst, 'MegashockValue': msv})
v = self.compute_fundamental_at_timestamp(current_time, 0, symbol, pt, pv)
return v
def get_daily_open_price(self, symbol: str, mkt_open: NanosecondTime, cents: bool=True) -> int:
'Return the daily open price for the symbol given.\n\n In the case of the MeanRevertingOracle, this will simply be the first\n fundamental value, which is also the fundamental mean. We will use the\n mkt_open time as given, however, even if it disagrees with this.\n '
logger.debug('Oracle: client requested {} at market open: {}'.format(symbol, self.mkt_open))
open_price = self.symbols[symbol]['r_bar']
logger.debug('Oracle: market open price was was {}'.format(open_price))
return open_price
def observe_price(self, symbol: str, current_time: NanosecondTime, random_state: np.random.RandomState, sigma_n: int=1000) -> int:
'Return a noisy observation of the current fundamental value.\n\n While the fundamental value for a given equity at a given time step does\n not change, multiple agents observing that value will receive different\n observations.\n\n Only the Exchange or other privileged agents should use sigma_n==0.\n\n sigma_n is experimental observation variance. NOTE: NOT STANDARD DEVIATION.\n\n Each agent must pass its RandomState object to observe_price. This ensures that\n each agent will receive the same answers across multiple same-seed simulations\n even if a new agent has been added to the experiment.\n '
if (current_time >= self.mkt_close):
r_t = self.advance_fundamental_value_series((self.mkt_close - 1), symbol)
else:
r_t = self.advance_fundamental_value_series(current_time, symbol)
if (sigma_n == 0):
obs = r_t
else:
obs = int(round(random_state.normal(loc=r_t, scale=sqrt(sigma_n))))
logger.debug('Oracle: current fundamental value is {} at {}'.format(r_t, current_time))
logger.debug('Oracle: giving client value observation {}'.format(obs))
return obs
|
class Side(Enum):
BID = 'BID'
ASK = 'ASK'
def is_bid(self) -> bool:
return (self == Side.BID)
def is_ask(self) -> bool:
return (self == Side.ASK)
|
class Order(ABC):
'A basic Order type used by an Exchange to conduct trades or maintain an order book.\n\n This should not be confused with order Messages agents send to request an Order.\n Specific order types will inherit from this (like LimitOrder).\n '
_order_id_counter: int = 0
@abstractmethod
def __init__(self, agent_id: int, time_placed: NanosecondTime, symbol: str, quantity: int, side: Side, order_id: Optional[int]=None, tag: Any=None) -> None:
'\n Arguments:\n agent_id: The ID of the agent that created this order.\n time_placed: Time at which the order was created by the agent.\n symbol: Equity symbol for the order.\n quantity: Number of equity units affected by the order.\n side: Indicates if an order is on the BID or ASK side of the market.\n order_id: Either self generated or assigned. Should only be self\n generated by the OrderBook class.\n tag: A free-form user-defined field that can contain any information\n relevant to the entity placing the order. Recommend keeping it\n alphanumeric rather than shoving in objects, as it will be there\n taking memory for the lifetime of the order and in all logging\n mechanisms. Intent: for strategy agents to set tags to help keep\n track of the intent of particular orders, to simplify their code.\n '
self.agent_id: int = agent_id
self.time_placed: NanosecondTime = time_placed
self.symbol: str = symbol
self.quantity: int = quantity
self.side: Side = side
if (order_id is None):
order_id = Order._order_id_counter
Order._order_id_counter += 1
self.order_id: int = order_id
self.fill_price: Optional[int] = None
self.tag: Optional[Any] = tag
def to_dict(self) -> Dict[(str, Any)]:
as_dict = deepcopy(self).__dict__
as_dict['time_placed'] = fmt_ts(self.time_placed)
return as_dict
def __eq__(self, other):
return ((type(other) is type(self)) and (self.__dict__ == other.__dict__))
def __deepcopy__(self, memodict={}):
raise NotImplementedError
|
class LimitOrder(Order):
"\n LimitOrder class that inherits from Order class and adds a limit price and a\n hidden order flag.\n\n These are the Orders that typically go in an Exchange's OrderBook.\n "
def __init__(self, agent_id: int, time_placed: NanosecondTime, symbol: str, quantity: int, side: Side, limit_price: int, is_hidden: bool=False, is_price_to_comply: bool=False, insert_by_id: bool=False, is_post_only=False, order_id: Optional[int]=None, tag: Optional[Any]=None) -> None:
super().__init__(agent_id, time_placed, symbol, quantity, side, order_id, tag=tag)
self.limit_price: int = limit_price
self.is_hidden: bool = is_hidden
self.is_price_to_comply: bool = is_price_to_comply
self.insert_by_id: bool = insert_by_id
self.is_post_only: bool = is_post_only
def __str__(self) -> str:
filled = ''
if self.fill_price:
filled = ' (filled @ {})'.format(dollarize(self.fill_price))
return '(Agent {} @ {}{}) : {} {} {} @ {}{}'.format(self.agent_id, fmt_ts(self.time_placed), (f' [{self.tag}]' if (self.tag is not None) else ''), self.side.value, self.quantity, self.symbol, (dollarize(self.limit_price) if (abs(self.limit_price) < sys.maxsize) else 'MKT'), filled)
def __repr__(self) -> str:
return self.__str__()
def __deepcopy__(self, memodict={}) -> 'LimitOrder':
tag = (None if (self.tag is None) else deepcopy(self.tag))
order = LimitOrder(self.agent_id, self.time_placed, self.symbol, self.quantity, self.side, self.limit_price, self.is_hidden, self.is_price_to_comply, self.insert_by_id, order_id=self.order_id, is_post_only=self.is_post_only, tag=tag)
order.fill_price = self.fill_price
return order
|
class MarketOrder(Order):
'MarketOrder class, inherits from Order class.'
def __init__(self, agent_id: int, time_placed: NanosecondTime, symbol: str, quantity: int, side: Side, order_id: Optional[int]=None, tag: Optional[Any]=None) -> None:
super().__init__(agent_id, time_placed, symbol, quantity, side, order_id=order_id, tag=tag)
def __str__(self) -> str:
return '(Agent {} @ {}) : MKT Order {} {} {}'.format(self.agent_id, fmt_ts(self.time_placed), self.side.value, self.quantity, self.symbol)
def __repr__(self) -> str:
return self.__str__()
def __deepcopy__(self, memodict={}) -> 'MarketOrder':
tag = (None if (self.tag is None) else deepcopy(self.tag))
order = MarketOrder(self.agent_id, self.time_placed, self.symbol, self.quantity, self.side, order_id=self.order_id, tag=tag)
order.fill_price = self.fill_price
return order
|
class PriceLevel():
'\n A class that represents a single price level containing multiple orders for one\n side of an order book. The option to have hidden orders is supported. This class\n abstracts the complextity of handling both visible and hidden orders away from\n the parent order book.\n\n Visible orders are consumed first, followed by any hidden orders.\n\n Attributes:\n visible_orders: A list of visible orders, where the order with index=0 is first\n in the queue and will be exexcuted first.\n hidden_orders: A list of hidden orders, where the order with index=0 is first\n in the queue and will be exexcuted first.\n price: The price this PriceLevel represents.\n side: The side of the market this PriceLevel represents.\n '
def __init__(self, orders: List[Tuple[(LimitOrder, Dict)]]) -> None:
'\n Arguments:\n orders: A list of orders, containing both visible and hidden orders that\n will be correctly allocated on initialisation. At least one order must\n be given.\n '
if (len(orders) == 0):
raise ValueError('At least one LimitOrder must be given when initialising a PriceLevel.')
self.visible_orders: List[Tuple[(LimitOrder, Dict)]] = []
self.hidden_orders: List[Tuple[(LimitOrder, Dict)]] = []
self.price: int = orders[0][0].limit_price
self.side: Side = orders[0][0].side
for (order, metadata) in orders:
self.add_order(order, metadata)
def add_order(self, order: LimitOrder, metadata: Optional[Dict]=None) -> None:
'\n Adds an order to the correct queue in the price level.\n\n Orders are added to the back of their respective queue.\n\n Arguments:\n order: The `LimitOrder` to add, can be visible or hidden.\n metadata: Optional dict of metadata values to associate with the order.\n '
if order.is_hidden:
self.hidden_orders.append((order, (metadata or {})))
elif order.insert_by_id:
insert_index = 0
for (order2, _) in self.visible_orders:
if (order2.order_id > order.order_id):
break
insert_index += 1
self.visible_orders.insert(insert_index, (order, (metadata or {})))
else:
self.visible_orders.append((order, (metadata or {})))
def update_order_quantity(self, order_id: int, new_quantity: int) -> bool:
"\n Updates the quantity of an order.\n\n The new_quantity must be greater than 0. To remove an order from the price\n level use the `remove_order` method instead.\n\n If the new quantity is less than or equal to the current quantity the order's\n position in its respective queue will be maintained.\n\n If the new quantity is more than the current quantity the order will be moved\n to the back of its respective queue.\n\n Arguments:\n order_id: The ID of the order to update.\n quantity: The new quantity to update with.\n\n Returns:\n True if the update was sucessful, False if a matching order with the\n given ID could not be found or if the new quantity given is 0.\n "
if (new_quantity == 0):
return False
for (i, (order, metadata)) in enumerate(self.visible_orders):
if (order.order_id == order_id):
if (new_quantity <= order.quantity):
order.quantity = new_quantity
else:
self.visible_orders.pop(i)
order.quantity = new_quantity
self.visible_orders.append((order, metadata))
return True
for (i, (order, metadata)) in enumerate(self.hidden_orders):
if (order.order_id == order_id):
if (new_quantity <= order.quantity):
order.quantity = new_quantity
else:
self.hidden_orders.pop(i)
order.quantity = new_quantity
self.hidden_orders.append((order, metadata))
return True
return False
def remove_order(self, order_id: int) -> Optional[Tuple[(LimitOrder, Dict)]]:
'\n Attempts to remove an order from the price level.\n\n Arguments:\n order_id: The ID of the order to remove.\n\n Returns:\n The order object if the order was found and removed, else None.\n '
for (i, (book_order, _)) in enumerate(self.visible_orders):
if (book_order.order_id == order_id):
return self.visible_orders.pop(i)
for (i, (book_order, _)) in enumerate(self.hidden_orders):
if (book_order.order_id == order_id):
return self.hidden_orders.pop(i)
return None
def peek(self) -> Tuple[(LimitOrder, Dict)]:
'\n Returns the highest priority order in the price level. Visible orders are returned first,\n followed by hidden orders if no visible order exist.\n\n Raises a ValueError exception if the price level has no orders.\n '
if (len(self.visible_orders) > 0):
return self.visible_orders[0]
elif (len(self.hidden_orders) > 0):
return self.hidden_orders[0]
else:
raise ValueError("Can't peek at LimitOrder in PriceLevel as it contains no orders")
def pop(self) -> Tuple[(LimitOrder, Dict)]:
'\n Removes the highest priority order in the price level and returns it. Visible\n orders are returned first, followed by hidden orders if no visible order exist.\n\n Raises a ValueError exception if the price level has no orders.\n '
if (len(self.visible_orders) > 0):
return self.visible_orders.pop(0)
elif (len(self.hidden_orders) > 0):
return self.hidden_orders.pop(0)
else:
raise ValueError("Can't pop LimitOrder from PriceLevel as it contains no orders")
def order_is_match(self, order: LimitOrder) -> bool:
'\n Checks if an order on the opposite side of the book is a match with this price\n level.\n\n The given order must be a `LimitOrder`.\n\n Arguments:\n order: The order to compare.\n\n Returns:\n True if the order is a match.\n '
if (order.side == self.side):
raise ValueError('Attempted to compare order on wrong side of book')
if (order.side.is_bid() and (order.limit_price >= self.price) and (not (order.is_post_only and (self.total_quantity == 0)))):
return True
if (order.side.is_ask() and (order.limit_price <= self.price) and (not (order.is_post_only and (self.total_quantity == 0)))):
return True
return False
def order_has_better_price(self, order: LimitOrder) -> bool:
'\n Checks if an order on this side of the book has a better price than this price\n level.\n\n Arguments:\n order: The order to compare.\n\n Returns:\n True if the given order has a better price.\n '
if (order.side != self.side):
raise ValueError('Attempted to compare order on wrong side of book')
if (order.side.is_bid() and (order.limit_price > self.price)):
return True
if (order.side.is_ask() and (order.limit_price < self.price)):
return True
return False
def order_has_worse_price(self, order: LimitOrder) -> bool:
'\n Checks if an order on this side of the book has a worse price than this price\n level.\n\n Arguments:\n order: The order to compare.\n\n Returns:\n True if the given order has a worse price.\n '
if (order.side != self.side):
raise ValueError('Attempted to compare order on wrong side of book')
if (order.side.is_bid() and (order.limit_price < self.price)):
return True
if (order.side.is_ask() and (order.limit_price > self.price)):
return True
return False
def order_has_equal_price(self, order: LimitOrder) -> bool:
'\n Checks if an order on this side of the book has an equal price to this price\n level.\n\n Arguments:\n order: The order to compare.\n\n Returns:\n True if the given order has an equal price.\n '
if (order.side != self.side):
raise ValueError('Attempted to compare order on wrong side of book')
return (order.limit_price == self.price)
@property
def total_quantity(self) -> int:
'\n Returns the total visible order quantity of this price level.\n '
return sum((order.quantity for (order, _) in self.visible_orders))
@property
def is_empty(self) -> bool:
'\n Returns True if this price level has no orders.\n '
return ((len(self.visible_orders) == 0) and (len(self.hidden_orders) == 0))
def __eq__(self, other: object) -> bool:
if (not isinstance(other, PriceLevel)):
raise NotImplementedError
return ((self.visible_orders == other.visible_orders) and (self.hidden_orders == other.hidden_orders))
|
def delist(list_of_lists):
return [x for b in list_of_lists for x in b]
|
def numeric(s):
'Returns numeric type from string, stripping commas from the right.\n\n Adapted from https://stackoverflow.com/a/379966.\n '
s = s.rstrip(',')
try:
return int(s)
except ValueError:
try:
return float(s)
except ValueError:
return s
|
def get_value_from_timestamp(s: pd.Series, ts: datetime.datetime):
'Get the value of s corresponding to closest datetime to ts.\n\n Arguments:\n s: Pandas Series with pd.DatetimeIndex.\n ts: Timestamp at which to retrieve data.\n '
ts_str = ts.strftime('%Y-%m-%d %H:%M:%S')
s = s.loc[(~ s.index.duplicated(keep='last'))]
locs = s.index.get_loc(ts_str, method='nearest')
out = (s[locs][0] if (isinstance(s[locs], np.ndarray) or isinstance(s[locs], pd.Series)) else s[locs])
return out
|
@contextmanager
def ignored(warning_str, *exceptions):
'Context manager that wraps the code block in a try except statement, catching\n specified exceptions and printing warning supplied by user.\n\n Arguments:\n warning_str: Warning statement printed when exception encountered.\n exceptions: An exception type, e.g. ``ValueError``.\n\n https://stackoverflow.com/a/15573313\n '
try:
(yield)
except exceptions:
warnings.warn(warning_str, UserWarning, stacklevel=1)
print(warning_str)
|
def generate_uniform_random_pairwise_dist_on_line(left: float, right: float, num_points: int, random_state: np.random.RandomState) -> np.ndarray:
'Uniformly generate points on an interval, and return numpy array of pairwise\n distances between points.\n\n Arguments:\n left: Left endpoint of interval.\n right: Right endpoint of interval.\n num_points: Number of points to use.\n random_state: ``np.random.RandomState`` object.\n '
x_coords = random_state.uniform(low=left, high=right, size=num_points)
x_coords = x_coords.reshape((x_coords.size, 1))
out = pdist(x_coords, 'euclidean')
return squareform(out)
|
def meters_to_light_ns(x):
'Converts x in units of meters to light nanoseconds.'
x_lns = (x / 0.299792458)
x_lns = x_lns.astype(int)
return x_lns
|
def validate_window_size(s):
"Check if s is integer or string 'adaptive'."
try:
return int(s)
except ValueError:
if (s.lower() == 'adaptive'):
return s.lower()
else:
raise ValueError(f'String {s} must be integer or string "adaptive".')
|
def sigmoid(x, beta):
'Numerically stable sigmoid function.\n\n Adapted from https://timvieira.github.io/blog/post/2014/02/11/exp-normalize-trick/"\n '
if (x >= 0):
z = np.exp(((- beta) * x))
return (1 / (1 + z))
else:
z = np.exp((beta * x))
return (z / (1 + z))
|
def subdict(d, keys):
return dict(((k, v) for (k, v) in d.items() if (k in keys)))
|
def restrictdict(d, keys):
inter = [k for k in d.keys() if (k in keys)]
return subdict(d, inter)
|
def dollarize(cents: Union[(List[int], int)]) -> Union[(List[str], str)]:
'Dollarizes int-cents prices for printing.\n\n Defined outside the class for utility access by non-agent classes.\n\n Arguments:\n cents:\n '
if isinstance(cents, list):
return [dollarize(x) for x in cents]
elif isinstance(cents, (int, np.int64)):
return '${:0.2f}'.format((cents / 100))
else:
raise ValueError(f"dollarize(cents) called without int or list of ints: {cents} (got type '{type(cents)}')")
|
def generate_latency_model(agent_count, latency_type='deterministic'):
assert (latency_type in ['deterministic', 'no_latency']), 'Please select a correct latency_type'
latency_rstate = np.random.RandomState(seed=np.random.randint(low=0, high=(2 ** 32)))
pairwise = (agent_count, agent_count)
if (latency_type == 'deterministic'):
nyc_to_seattle_meters = 3866660
pairwise_distances = generate_uniform_random_pairwise_dist_on_line(0.0, nyc_to_seattle_meters, agent_count, random_state=latency_rstate)
pairwise_latencies = meters_to_light_ns(pairwise_distances)
else:
pairwise_latencies = np.zeros(pairwise, dtype=int)
latency_model = LatencyModel(latency_model='deterministic', random_state=latency_rstate, connected=True, min_latency=pairwise_latencies)
return latency_model
|
def config_add_agents(orig_config_state, agents):
agent_count = len(orig_config_state['agents'])
orig_config_state['agents'] = (orig_config_state['agents'] + agents)
lat_mod = generate_latency_model((agent_count + len(agents)))
orig_config_state['agent_latency_model'] = lat_mod
return orig_config_state
|
def reset_env():
Order._order_id_counter = 0
|
def test_poisson_time_generator():
gen = PoissonTimeGenerator(lambda_time=2, random_generator=np.random.RandomState(seed=1))
for _ in range(10):
print(gen.next())
|
class FakeExchangeAgent():
def __init__(self):
self.messages = []
self.current_time = TIME
self.mkt_open = TIME
self.book_logging = None
self.stream_history = 10
def reset(self):
self.messages = []
def send_message(self, recipient_id: int, message: Message, _: int=0):
self.messages.append((recipient_id, message))
def logEvent(self, *args, **kwargs):
pass
|
def setup_book_with_orders(bids: List[Tuple[(int, List[int])]]=[], asks: List[Tuple[(int, List[int])]]=[]) -> Tuple[(OrderBook, FakeExchangeAgent, List[LimitOrder])]:
agent = FakeExchangeAgent()
book = OrderBook(agent, SYMBOL)
orders = []
for (price, quantities) in bids:
for quantity in quantities:
order = LimitOrder(1, TIME, SYMBOL, quantity, Side.BID, price)
book.handle_limit_order(order)
orders.append(order)
for (price, quantities) in asks:
for quantity in quantities:
order = LimitOrder(1, TIME, SYMBOL, quantity, Side.ASK, price)
book.handle_limit_order(order)
orders.append(order)
agent.reset()
return (book, agent, orders)
|
def test_cancel_order():
(book, agent, orders) = setup_book_with_orders(bids=[(100, [40, 10]), (200, [10, 30, 20, 10])], asks=[(300, [10, 50, 20]), (400, [40, 10]), (500, [20])])
book.cancel_order(orders[1])
assert (book.get_l3_bid_data() == [(200, [10, 30, 20, 10]), (100, [40])])
assert (len(agent.messages) == 1)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.BID)
assert (agent.messages[0][1].order.limit_price == 100)
assert (agent.messages[0][1].order.quantity == 10)
agent.reset()
book.cancel_order(orders[(- 1)])
assert (book.get_l3_ask_data() == [(300, [10, 50, 20]), (400, [40, 10])])
assert (len(agent.messages) == 1)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.ASK)
assert (agent.messages[0][1].order.limit_price == 500)
assert (agent.messages[0][1].order.quantity == 20)
|
def test_get_l1_bid_ask_data():
(book, _, _) = setup_book_with_orders(bids=[], asks=[])
assert (book.get_l1_bid_data() == None)
assert (book.get_l1_ask_data() == None)
(book, _, _) = setup_book_with_orders(bids=[(100, [40, 10]), (200, [10, 30, 20, 10])], asks=[(300, [10, 50, 20]), (400, [40, 10]), (500, [20])])
assert (book.get_l1_bid_data() == (200, 70))
assert (book.get_l1_ask_data() == (300, 80))
|
def test_get_l2_bid_ask_data():
(book, _, _) = setup_book_with_orders(bids=[], asks=[])
assert (book.get_l2_bid_data() == [])
assert (book.get_l2_ask_data() == [])
(book, _, _) = setup_book_with_orders(bids=[(100, [40, 10]), (200, [10, 30, 20, 10])], asks=[(300, [10, 50, 20]), (400, [40, 10]), (500, [20])])
assert (book.get_l2_bid_data() == [(200, 70), (100, 50)])
assert (book.get_l2_ask_data() == [(300, 80), (400, 50), (500, 20)])
|
def test_get_l3_bid_ask_data():
(book, _, _) = setup_book_with_orders(bids=[], asks=[])
assert (book.get_l3_bid_data() == [])
assert (book.get_l3_ask_data() == [])
(book, _, _) = setup_book_with_orders(bids=[(100, [40, 10]), (200, [10, 30, 20, 10])], asks=[(300, [10, 50, 20]), (400, [40, 10]), (500, [20])])
assert (book.get_l3_bid_data() == [(200, [10, 30, 20, 10]), (100, [40, 10])])
assert (book.get_l3_ask_data() == [(300, [10, 50, 20]), (400, [40, 10]), (500, [20])])
|
def test_get_transacted_volume():
(book, _, _) = setup_book_with_orders(bids=[(100, [40, 10]), (200, [10, 30, 20, 10])], asks=[(300, [10, 50, 20]), (400, [40, 10]), (500, [20])])
for q in [10, 30, 20, 10]:
order = MarketOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=q, side=Side.BID)
book.handle_market_order(order)
assert (book.get_transacted_volume() == (sum([10, 30, 20, 10]), 0))
for q in [50, 10, 40]:
order = MarketOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=q, side=Side.ASK)
book.handle_market_order(order)
assert (book.get_transacted_volume() == (sum([10, 30, 20, 10]), sum([50, 10, 40])))
|
def test_get_imbalance():
(book, _, _) = setup_book_with_orders(bids=[(100, [10])], asks=[(200, [10])])
assert (book.get_imbalance() == (0, None))
(book, _, _) = setup_book_with_orders(bids=[(100, [20])], asks=[(200, [10])])
assert (book.get_imbalance() == (0.5, Side.BID))
(book, _, _) = setup_book_with_orders(bids=[(100, [10])], asks=[(200, [20])])
assert (book.get_imbalance() == (0.5, Side.ASK))
(book, _, _) = setup_book_with_orders(bids=[(100, [100])], asks=[(200, [10])])
assert (book.get_imbalance() == (0.9, Side.BID))
(book, _, _) = setup_book_with_orders(bids=[(100, [10])], asks=[(200, [100])])
assert (book.get_imbalance() == (0.9, Side.ASK))
(book, _, _) = setup_book_with_orders(bids=[(100, [20])], asks=[])
assert (book.get_imbalance() == (1.0, Side.BID))
(book, _, _) = setup_book_with_orders(bids=[], asks=[(200, [20])])
assert (book.get_imbalance() == (1.0, Side.ASK))
|
def test_handle_limit_orders():
bid_order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.BID, limit_price=100)
agent = FakeExchangeAgent()
book = OrderBook(agent, SYMBOL)
book.handle_limit_order(bid_order)
assert (book.bids == [PriceLevel([(bid_order, {})])])
assert (book.asks == [])
assert (len(agent.messages) == 1)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.BID)
assert (agent.messages[0][1].order.limit_price == 100)
assert (agent.messages[0][1].order.quantity == 10)
ask_order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.ASK, limit_price=100)
agent = FakeExchangeAgent()
book = OrderBook(agent, SYMBOL)
book.handle_limit_order(ask_order)
assert (book.bids == [])
assert (book.asks == [PriceLevel([(ask_order, {})])])
assert (len(agent.messages) == 1)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.ASK)
assert (agent.messages[0][1].order.limit_price == 100)
assert (agent.messages[0][1].order.quantity == 10)
|
def test_handle_hidden_limit_orders():
bid_order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.BID, is_hidden=True, limit_price=100)
agent = FakeExchangeAgent()
book = OrderBook(agent, SYMBOL)
book.handle_limit_order(bid_order)
assert (book.bids == [PriceLevel([(bid_order, {})])])
assert (book.asks == [])
assert (len(agent.messages) == 1)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.BID)
assert (agent.messages[0][1].order.is_hidden == True)
assert (agent.messages[0][1].order.limit_price == 100)
assert (agent.messages[0][1].order.quantity == 10)
ask_order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.ASK, is_hidden=True, limit_price=100)
agent = FakeExchangeAgent()
book = OrderBook(agent, SYMBOL)
book.handle_limit_order(ask_order)
assert (book.bids == [])
assert (book.asks == [PriceLevel([(ask_order, {})])])
assert (len(agent.messages) == 1)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.ASK)
assert (agent.messages[0][1].order.is_hidden == True)
assert (agent.messages[0][1].order.limit_price == 100)
assert (agent.messages[0][1].order.quantity == 10)
|
def test_handle_matching_limit_orders():
(book, agent, _) = setup_book_with_orders(asks=[(100, [30])])
bid_order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=30, side=Side.BID, is_hidden=False, limit_price=110)
book.handle_limit_order(bid_order)
assert (book.bids == [])
assert (book.asks == [])
assert (len(agent.messages) == 2)
assert (agent.messages[0][0] == 1)
assert isinstance(agent.messages[0][1], OrderExecutedMsg)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.ASK)
assert (agent.messages[0][1].order.limit_price == 100)
assert (agent.messages[1][1].order.fill_price == 100)
assert (agent.messages[0][1].order.quantity == 30)
assert (agent.messages[1][0] == 1)
assert isinstance(agent.messages[1][1], OrderExecutedMsg)
assert (agent.messages[1][1].order.agent_id == 1)
assert (agent.messages[1][1].order.side == Side.BID)
assert (agent.messages[1][1].order.limit_price == 110)
assert (agent.messages[1][1].order.fill_price == 100)
assert (agent.messages[1][1].order.quantity == 30)
(book, agent, _) = setup_book_with_orders(bids=[(100, [30])])
ask_order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=30, side=Side.ASK, is_hidden=False, limit_price=90)
book.handle_limit_order(ask_order)
assert (book.bids == [])
assert (book.asks == [])
assert (len(agent.messages) == 2)
assert (agent.messages[0][0] == 1)
assert isinstance(agent.messages[0][1], OrderExecutedMsg)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.BID)
assert (agent.messages[0][1].order.limit_price == 100)
assert (agent.messages[1][1].order.fill_price == 100)
assert (agent.messages[0][1].order.quantity == 30)
assert (agent.messages[1][0] == 1)
assert isinstance(agent.messages[1][1], OrderExecutedMsg)
assert (agent.messages[1][1].order.agent_id == 1)
assert (agent.messages[1][1].order.side == Side.ASK)
assert (agent.messages[1][1].order.limit_price == 90)
assert (agent.messages[1][1].order.fill_price == 100)
assert (agent.messages[1][1].order.quantity == 30)
|
def test_handle_bad_limit_orders():
agent = FakeExchangeAgent()
book = OrderBook(agent, SYMBOL)
order = LimitOrder(agent_id=1, time_placed=TIME, symbol='BAD', quantity=10, side=Side.BID, is_hidden=True, limit_price=100)
with pytest.warns(UserWarning):
book.handle_limit_order(order)
order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=1.5, side=Side.BID, is_hidden=True, limit_price=100)
with pytest.warns(UserWarning):
book.handle_limit_order(order)
order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=(- 10), side=Side.BID, is_hidden=True, limit_price=100)
with pytest.warns(UserWarning):
book.handle_limit_order(order)
with pytest.warns(UserWarning):
book.handle_limit_order(order)
order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.BID, is_hidden=True, limit_price=(- 100))
with pytest.warns(UserWarning):
book.handle_limit_order(order)
|
def test_handle_insert_by_id_limit_order():
agent = FakeExchangeAgent()
book = OrderBook(agent, SYMBOL)
order1 = LimitOrder(order_id=1, agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.BID, limit_price=100)
order2 = LimitOrder(order_id=2, agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=20, side=Side.BID, limit_price=100)
order3 = LimitOrder(order_id=3, agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=30, side=Side.BID, limit_price=100, insert_by_id=True)
order4 = LimitOrder(order_id=4, agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=40, side=Side.BID, limit_price=100)
book.handle_limit_order(order1)
book.handle_limit_order(order2)
book.handle_limit_order(order4)
book.handle_limit_order(order3)
assert (book.bids[0].visible_orders == [(order1, {}), (order2, {}), (order3, {}), (order4, {})])
|
def test_handle_market_order_bid_1():
'Test buy order that partially consumes one order'
(book, agent, limit_orders) = setup_book_with_orders(asks=[(100, [30])])
market_order = MarketOrder(agent_id=2, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.BID)
book.handle_market_order(market_order)
assert (book.get_l3_ask_data() == [(100, [20])])
assert (len(agent.messages) == 2)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.ASK)
assert (agent.messages[0][1].order.fill_price == 100)
assert (agent.messages[0][1].order.quantity == 10)
assert (agent.messages[1][0] == 2)
assert (agent.messages[1][1].order.agent_id == 2)
assert (agent.messages[1][1].order.side == Side.BID)
assert (agent.messages[1][1].order.fill_price == 100)
assert (agent.messages[1][1].order.quantity == 10)
|
def test_handle_market_order_bid_2():
'Test buy order that fully consumes one order'
(book, agent, limit_orders) = setup_book_with_orders(asks=[(100, [30])])
market_order = MarketOrder(agent_id=2, time_placed=TIME, symbol=SYMBOL, quantity=30, side=Side.BID)
book.handle_market_order(market_order)
assert (book.get_l3_ask_data() == [])
assert (len(agent.messages) == 2)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.ASK)
assert (agent.messages[0][1].order.fill_price == 100)
assert (agent.messages[0][1].order.quantity == 30)
assert (agent.messages[1][0] == 2)
assert (agent.messages[1][1].order.agent_id == 2)
assert (agent.messages[1][1].order.side == Side.BID)
assert (agent.messages[1][1].order.fill_price == 100)
assert (agent.messages[1][1].order.quantity == 30)
|
def test_handle_market_order_bid_3():
'Test buy order that consumes multiple orders'
(book, agent, limit_orders) = setup_book_with_orders(asks=[(100, [30, 40])])
market_order = MarketOrder(agent_id=2, time_placed=TIME, symbol=SYMBOL, quantity=70, side=Side.BID)
book.handle_market_order(market_order)
assert (book.get_l3_ask_data() == [])
assert (len(agent.messages) == 4)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.ASK)
assert (agent.messages[0][1].order.fill_price == 100)
assert (agent.messages[0][1].order.quantity == 30)
assert (agent.messages[1][0] == 2)
assert (agent.messages[1][1].order.agent_id == 2)
assert (agent.messages[1][1].order.side == Side.BID)
assert (agent.messages[1][1].order.fill_price == 100)
assert (agent.messages[1][1].order.quantity == 30)
assert (agent.messages[2][0] == 1)
assert (agent.messages[2][1].order.agent_id == 1)
assert (agent.messages[2][1].order.side == Side.ASK)
assert (agent.messages[2][1].order.fill_price == 100)
assert (agent.messages[2][1].order.quantity == 40)
assert (agent.messages[3][0] == 2)
assert (agent.messages[3][1].order.agent_id == 2)
assert (agent.messages[3][1].order.side == Side.BID)
assert (agent.messages[3][1].order.fill_price == 100)
assert (agent.messages[3][1].order.quantity == 40)
|
def test_handle_market_order_bid_4():
'Test buy order that consumes multiple orders at different prices'
(book, agent, limit_orders) = setup_book_with_orders(asks=[(100, [30]), (200, [40])])
market_order = MarketOrder(agent_id=2, time_placed=TIME, symbol=SYMBOL, quantity=70, side=Side.BID)
book.handle_market_order(market_order)
assert (book.get_l3_ask_data() == [])
assert (len(agent.messages) == 4)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.ASK)
assert (agent.messages[0][1].order.fill_price == 100)
assert (agent.messages[0][1].order.quantity == 30)
assert (agent.messages[1][0] == 2)
assert (agent.messages[1][1].order.agent_id == 2)
assert (agent.messages[1][1].order.side == Side.BID)
assert (agent.messages[1][1].order.fill_price == 100)
assert (agent.messages[1][1].order.quantity == 30)
assert (agent.messages[2][0] == 1)
assert (agent.messages[2][1].order.agent_id == 1)
assert (agent.messages[2][1].order.side == Side.ASK)
assert (agent.messages[2][1].order.fill_price == 200)
assert (agent.messages[2][1].order.quantity == 40)
assert (agent.messages[3][0] == 2)
assert (agent.messages[3][1].order.agent_id == 2)
assert (agent.messages[3][1].order.side == Side.BID)
assert (agent.messages[3][1].order.fill_price == 200)
assert (agent.messages[3][1].order.quantity == 40)
|
def test_handle_market_order_ask_1():
'Test sell order that partially consumes one order'
(book, agent, limit_orders) = setup_book_with_orders(bids=[(100, [30])])
market_order = MarketOrder(agent_id=2, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.ASK)
book.handle_market_order(market_order)
assert (book.get_l3_bid_data() == [(100, [20])])
assert (len(agent.messages) == 2)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.BID)
assert (agent.messages[0][1].order.fill_price == 100)
assert (agent.messages[0][1].order.quantity == 10)
assert (agent.messages[1][0] == 2)
assert (agent.messages[1][1].order.agent_id == 2)
assert (agent.messages[1][1].order.side == Side.ASK)
assert (agent.messages[1][1].order.fill_price == 100)
assert (agent.messages[1][1].order.quantity == 10)
|
def test_handle_market_order_ask_2():
'Test sell order that fully consumes one order'
(book, agent, limit_orders) = setup_book_with_orders(bids=[(100, [30])])
market_order = MarketOrder(agent_id=2, time_placed=TIME, symbol=SYMBOL, quantity=30, side=Side.ASK)
book.handle_market_order(market_order)
assert (book.get_l3_bid_data() == [])
assert (len(agent.messages) == 2)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.BID)
assert (agent.messages[0][1].order.fill_price == 100)
assert (agent.messages[0][1].order.quantity == 30)
assert (agent.messages[1][0] == 2)
assert (agent.messages[1][1].order.agent_id == 2)
assert (agent.messages[1][1].order.side == Side.ASK)
assert (agent.messages[1][1].order.fill_price == 100)
assert (agent.messages[1][1].order.quantity == 30)
|
def test_handle_market_order_ask_3():
'Test sell order that consumes multiple orders'
(book, agent, limit_orders) = setup_book_with_orders(bids=[(100, [30, 40])])
market_order = MarketOrder(agent_id=2, time_placed=TIME, symbol=SYMBOL, quantity=70, side=Side.ASK)
book.handle_market_order(market_order)
assert (book.get_l3_bid_data() == [])
assert (len(agent.messages) == 4)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.BID)
assert (agent.messages[0][1].order.fill_price == 100)
assert (agent.messages[0][1].order.quantity == 30)
assert (agent.messages[1][0] == 2)
assert (agent.messages[1][1].order.agent_id == 2)
assert (agent.messages[1][1].order.side == Side.ASK)
assert (agent.messages[1][1].order.fill_price == 100)
assert (agent.messages[1][1].order.quantity == 30)
assert (agent.messages[2][0] == 1)
assert (agent.messages[2][1].order.agent_id == 1)
assert (agent.messages[2][1].order.side == Side.BID)
assert (agent.messages[2][1].order.fill_price == 100)
assert (agent.messages[2][1].order.quantity == 40)
assert (agent.messages[3][0] == 2)
assert (agent.messages[3][1].order.agent_id == 2)
assert (agent.messages[3][1].order.side == Side.ASK)
assert (agent.messages[3][1].order.fill_price == 100)
assert (agent.messages[3][1].order.quantity == 40)
|
def test_handle_market_order_ask_4():
'Test sell order that consumes multiple orders at different prices'
(book, agent, limit_orders) = setup_book_with_orders(bids=[(200, [40]), (100, [30])])
market_order = MarketOrder(agent_id=2, time_placed=TIME, symbol=SYMBOL, quantity=70, side=Side.ASK)
book.handle_market_order(market_order)
assert (book.get_l3_bid_data() == [])
assert (len(agent.messages) == 4)
assert (agent.messages[0][0] == 1)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.BID)
assert (agent.messages[0][1].order.fill_price == 200)
assert (agent.messages[0][1].order.quantity == 40)
assert (agent.messages[1][0] == 2)
assert (agent.messages[1][1].order.agent_id == 2)
assert (agent.messages[1][1].order.side == Side.ASK)
assert (agent.messages[1][1].order.fill_price == 200)
assert (agent.messages[1][1].order.quantity == 40)
assert (agent.messages[2][0] == 1)
assert (agent.messages[2][1].order.agent_id == 1)
assert (agent.messages[2][1].order.side == Side.BID)
assert (agent.messages[2][1].order.fill_price == 100)
assert (agent.messages[2][1].order.quantity == 30)
assert (agent.messages[3][0] == 2)
assert (agent.messages[3][1].order.agent_id == 2)
assert (agent.messages[3][1].order.side == Side.ASK)
assert (agent.messages[3][1].order.fill_price == 100)
assert (agent.messages[3][1].order.quantity == 30)
|
def test_handle_bad_limit_orders():
(book, _, _) = setup_book_with_orders()
order = MarketOrder(agent_id=1, time_placed=TIME, symbol='BAD', quantity=70, side=Side.ASK)
with pytest.warns(UserWarning):
book.handle_market_order(order)
order = MarketOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=1.5, side=Side.BID)
with pytest.warns(UserWarning):
book.handle_market_order(order)
order = MarketOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=(- 10), side=Side.BID)
with pytest.warns(UserWarning):
book.handle_market_order(order)
|
def test_modify_order_quantity_down():
(book, agent, orders) = setup_book_with_orders(bids=[(100, [40, 10]), (200, [10, 30, 20, 10])], asks=[(300, [10, 50, 20]), (400, [40, 10]), (500, [20])])
modified_order = deepcopy(orders[0])
modified_order.quantity = 30
book.modify_order(orders[0], modified_order)
assert (book.get_l3_bid_data() == [(200, [10, 30, 20, 10]), (100, [30, 10])])
assert (len(agent.messages) == 1)
assert (agent.messages[0][0] == 1)
assert isinstance(agent.messages[0][1], OrderModifiedMsg)
assert (agent.messages[0][1].new_order.agent_id == 1)
assert (agent.messages[0][1].new_order.side == Side.BID)
assert (agent.messages[0][1].new_order.limit_price == 100)
assert (agent.messages[0][1].new_order.quantity == 30)
|
def test_modify_order_quantity_up():
(book, agent, orders) = setup_book_with_orders(bids=[(100, [40, 10]), (200, [10, 30, 20, 10])], asks=[(300, [10, 50, 20]), (400, [40, 10]), (500, [20])])
modified_order = deepcopy(orders[0])
modified_order.quantity = 70
book.modify_order(orders[0], modified_order)
assert (book.get_l3_bid_data() == [(200, [10, 30, 20, 10]), (100, [10, 70])])
assert (len(agent.messages) == 1)
assert (agent.messages[0][0] == 1)
assert isinstance(agent.messages[0][1], OrderModifiedMsg)
assert (agent.messages[0][1].new_order.agent_id == 1)
assert (agent.messages[0][1].new_order.side == Side.BID)
assert (agent.messages[0][1].new_order.limit_price == 100)
assert (agent.messages[0][1].new_order.quantity == 70)
|
def test_empty_book():
book = OrderBook(FakeExchangeAgent(), SYMBOL)
assert (book.get_l1_bid_data() == None)
assert (book.get_l1_ask_data() == None)
assert (book.get_l2_bid_data() == [])
assert (book.get_l2_ask_data() == [])
assert (book.get_l3_bid_data() == [])
assert (book.get_l3_ask_data() == [])
assert (book.get_transacted_volume() == (0, 0))
|
@pytest.fixture
def price_level():
reset_env()
return PriceLevel([(LimitOrder(0, 0, '', 10, Side.BID, 100, is_hidden=False), {}), (LimitOrder(0, 0, '', 10, Side.BID, 100, is_hidden=True), {}), (LimitOrder(0, 0, '', 10, Side.BID, 100, is_hidden=False), {}), (LimitOrder(0, 0, '', 10, Side.BID, 100, is_hidden=True), {}), (LimitOrder(0, 0, '', 10, Side.BID, 100, is_hidden=False), {})])
|
def test_init(price_level):
assert (len(price_level.visible_orders) == 3)
assert (len(price_level.hidden_orders) == 2)
assert (price_level.price == 100)
assert (price_level.side == Side.BID)
|
def test_bad_init():
with pytest.raises(ValueError):
_ = PriceLevel([])
|
def test_add_order(price_level):
order = LimitOrder(0, 0, '', 10, Side.BID, 100, is_hidden=False)
price_level.add_order(order)
assert (price_level.visible_orders[(- 1)] == (order, {}))
order = LimitOrder(0, 0, '', 10, Side.BID, 100, is_hidden=True)
price_level.add_order(order)
assert (price_level.hidden_orders[(- 1)] == (order, {}))
|
def test_update_order_quantity(price_level):
assert (price_level.update_order_quantity(0, 5) == True)
assert (price_level.visible_orders[0][0].order_id == 0)
assert (price_level.update_order_quantity(0, 15) == True)
assert (price_level.visible_orders[(- 1)][0].order_id == 0)
assert (price_level.update_order_quantity(1, 5) == True)
assert (price_level.hidden_orders[0][0].order_id == 1)
assert (price_level.update_order_quantity(1, 15) == True)
assert (price_level.hidden_orders[(- 1)][0].order_id == 1)
assert (price_level.update_order_quantity(10, 5) == False)
|
def test_remove_order(price_level):
(order, _) = price_level.remove_order(0)
assert isinstance(order, LimitOrder)
assert (order.order_id == 0)
assert (len(price_level.visible_orders) == 2)
(order, _) = price_level.remove_order(1)
assert isinstance(order, LimitOrder)
assert (order.order_id == 1)
assert (len(price_level.hidden_orders) == 1)
assert (price_level.remove_order(10) == None)
|
def test_peek(price_level):
assert (price_level.peek() == price_level.visible_orders[0])
price_level.visible_orders = []
assert (price_level.peek() == price_level.hidden_orders[0])
price_level.hidden_orders = []
with pytest.raises(ValueError):
price_level.peek()
|
def test_pop(price_level):
order = price_level.visible_orders[0]
assert (price_level.pop() == order)
price_level.visible_orders = []
order = price_level.hidden_orders[0]
assert (price_level.pop() == order)
price_level.hidden_orders = []
with pytest.raises(ValueError):
price_level.pop()
|
def test_order_is_match(price_level):
order = LimitOrder(0, 0, '', 10, Side.ASK, 90, is_hidden=False)
assert (price_level.order_is_match(order) == True)
order = LimitOrder(0, 0, '', 10, Side.ASK, 100, is_hidden=False)
assert (price_level.order_is_match(order) == True)
order = LimitOrder(0, 0, '', 10, Side.ASK, 110, is_hidden=False)
assert (price_level.order_is_match(order) == False)
order = LimitOrder(0, 0, '', 10, Side.BID, 100, is_hidden=False)
with pytest.raises(ValueError):
price_level.order_is_match(order)
price_level.visible_orders = []
price_level.hidden_orders = []
with pytest.raises(ValueError):
price_level.order_is_match(order)
|
def test_order_has_better_price(price_level):
order = LimitOrder(0, 0, '', 10, Side.BID, 90, is_hidden=False)
assert (price_level.order_has_better_price(order) == False)
order = LimitOrder(0, 0, '', 10, Side.BID, 100, is_hidden=False)
assert (price_level.order_has_better_price(order) == False)
order = LimitOrder(0, 0, '', 10, Side.BID, 110, is_hidden=False)
assert (price_level.order_has_better_price(order) == True)
order = LimitOrder(0, 0, '', 10, Side.ASK, 100, is_hidden=False)
with pytest.raises(ValueError):
price_level.order_has_better_price(order)
price_level.visible_orders = []
price_level.hidden_orders = []
with pytest.raises(ValueError):
price_level.order_has_better_price(order)
|
def test_order_has_worse_price(price_level):
order = LimitOrder(0, 0, '', 10, Side.BID, 90, is_hidden=False)
assert (price_level.order_has_worse_price(order) == True)
order = LimitOrder(0, 0, '', 10, Side.BID, 100, is_hidden=False)
assert (price_level.order_has_worse_price(order) == False)
order = LimitOrder(0, 0, '', 10, Side.BID, 110, is_hidden=False)
assert (price_level.order_has_worse_price(order) == False)
order = LimitOrder(0, 0, '', 10, Side.ASK, 100, is_hidden=False)
with pytest.raises(ValueError):
price_level.order_has_worse_price(order)
price_level.visible_orders = []
price_level.hidden_orders = []
with pytest.raises(ValueError):
price_level.order_has_worse_price(order)
|
def test_order_has_equal_price(price_level):
order = LimitOrder(0, 0, '', 10, Side.BID, 90, is_hidden=False)
assert (price_level.order_has_equal_price(order) == False)
order = LimitOrder(0, 0, '', 10, Side.BID, 100, is_hidden=False)
assert (price_level.order_has_equal_price(order) == True)
order = LimitOrder(0, 0, '', 10, Side.BID, 110, is_hidden=False)
assert (price_level.order_has_worse_price(order) == False)
order = LimitOrder(0, 0, '', 10, Side.ASK, 100, is_hidden=False)
with pytest.raises(ValueError):
price_level.order_has_equal_price(order)
price_level.visible_orders = []
price_level.hidden_orders = []
with pytest.raises(ValueError):
price_level.order_has_equal_price(order)
|
def test_total_quantity(price_level):
assert (price_level.total_quantity == 30)
price_level.visible_orders = []
price_level.hidden_orders = []
assert (price_level.total_quantity == 0)
|
def test_is_empty(price_level):
assert (price_level.is_empty == False)
price_level.visible_orders = []
assert (price_level.is_empty == False)
price_level.hidden_orders = []
assert (price_level.is_empty == True)
|
def test_eq(price_level):
assert (price_level == price_level)
lo = LimitOrder(0, 0, '', 10, Side.BID, 90, is_hidden=False)
assert (PriceLevel([(lo, {})]) != price_level)
|
def test_create_price_to_comply_order():
order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.BID, is_price_to_comply=True, limit_price=100)
agent = FakeExchangeAgent()
book = OrderBook(agent, SYMBOL)
book.handle_limit_order(deepcopy(order))
hidden_half = deepcopy(order)
hidden_half.is_hidden = True
hidden_half.limit_price += 1
visible_half = order
assert (len(book.asks) == 0)
assert (len(book.bids) == 2)
assert (book.bids[0].hidden_orders == [(hidden_half, dict(ptc_hidden=True, ptc_other_half=visible_half))])
assert (book.bids[0].visible_orders == [])
assert (book.bids[1].hidden_orders == [])
assert (book.bids[1].visible_orders == [(visible_half, dict(ptc_hidden=False, ptc_other_half=hidden_half))])
|
def test_fill_price_to_comply_order():
order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.BID, is_price_to_comply=True, limit_price=100)
agent = FakeExchangeAgent()
book = OrderBook(agent, SYMBOL)
book.handle_limit_order(order)
hidden_half = deepcopy(order)
hidden_half.is_hidden = True
hidden_half.limit_price += 1
visible_half = order
market_order = MarketOrder(agent_id=2, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.ASK)
book.handle_market_order(market_order)
assert (len(book.asks) == 0)
assert (len(book.bids) == 0)
assert (len(agent.messages) == 3)
assert (agent.messages[0][0] == 1)
assert isinstance(agent.messages[0][1], OrderAcceptedMsg)
assert (agent.messages[0][1].order.agent_id == 1)
assert (agent.messages[0][1].order.side == Side.BID)
assert (agent.messages[0][1].order.quantity == 10)
assert (agent.messages[1][0] == 1)
assert isinstance(agent.messages[1][1], OrderExecutedMsg)
assert (agent.messages[1][1].order.agent_id == 1)
assert (agent.messages[1][1].order.side == Side.BID)
assert (agent.messages[1][1].order.fill_price == 101)
assert (agent.messages[1][1].order.quantity == 10)
assert (agent.messages[2][0] == 2)
assert isinstance(agent.messages[2][1], OrderExecutedMsg)
assert (agent.messages[2][1].order.agent_id == 2)
assert (agent.messages[2][1].order.side == Side.ASK)
assert (agent.messages[2][1].order.fill_price == 101)
assert (agent.messages[2][1].order.quantity == 10)
|
def test_cancel_price_to_comply_order():
order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.BID, is_price_to_comply=True, limit_price=100)
agent = FakeExchangeAgent()
book = OrderBook(agent, SYMBOL)
book.handle_limit_order(order)
assert (book.cancel_order(order) == True)
assert (len(book.asks) == 0)
assert (len(book.bids) == 0)
|
def test_modify_price_to_comply_order():
pass
|
def test_replace_price_to_comply_order():
old_order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.BID, is_price_to_comply=True, limit_price=100)
agent = FakeExchangeAgent()
book = OrderBook(agent, SYMBOL)
book.handle_limit_order(old_order)
assert (len(book.asks) == 0)
assert (len(book.bids) == 2)
new_order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=10, side=Side.ASK, is_price_to_comply=False, limit_price=100)
book.replace_order(1, old_order, new_order)
assert (len(book.asks) == 1)
assert (len(book.bids) == 0)
|
def test_replace_order():
(book, agent, orders) = setup_book_with_orders(bids=[(100, [40, 10]), (200, [10, 30, 20, 10])], asks=[(300, [10, 50, 20]), (400, [40, 10]), (500, [20])])
new_order = LimitOrder(agent_id=1, time_placed=TIME, symbol=SYMBOL, quantity=50, side=Side.BID, limit_price=100)
book.replace_order(1, orders[3], new_order)
assert (book.get_l3_bid_data() == [(200, [10, 20, 10]), (100, [40, 10, 50])])
assert (len(agent.messages) == 1)
assert (agent.messages[0][0] == 1)
assert isinstance(agent.messages[0][1], OrderReplacedMsg)
assert (agent.messages[0][1].old_order.agent_id == 1)
assert (agent.messages[0][1].old_order.side == Side.BID)
assert (agent.messages[0][1].old_order.limit_price == 200)
assert (agent.messages[0][1].old_order.quantity == 30)
assert (agent.messages[0][1].new_order.agent_id == 1)
assert (agent.messages[0][1].new_order.side == Side.BID)
assert (agent.messages[0][1].new_order.limit_price == 100)
assert (agent.messages[0][1].new_order.quantity == 50)
|
def test_constant_depth_generator():
g = ConstantDepthGenerator(10)
assert (g.next() == 10)
assert (g.mean() == 10)
|
def test_constant_order_size_generator():
g = ConstantOrderSizeGenerator(10)
assert (g.next() == 10)
assert (g.mean() == 10)
|
def test_uniform_depth_generator():
g = UniformDepthGenerator(0, 10, np.random.RandomState())
assert (g.mean() == 5)
|
def test_uniform_order_size_generator():
g = UniformOrderSizeGenerator(0, 10, np.random.RandomState())
assert (g.mean() == 5)
|
def test_gym_runner_markets_execution():
env = gym.make('markets-execution-v0', background_config='rmsc04')
env.seed(0)
state = env.reset()
for i in range(5):
(state, reward, done, info) = env.step(0)
env.step(1)
env.step(2)
env.seed()
env.reset()
env.close()
|
def test_gym_runner_markets_daily_investor():
env = gym.make('markets-daily_investor-v0', background_config='rmsc04')
env.seed(0)
state = env.reset()
for i in range(5):
(state, reward, done, info) = env.step(0)
env.step(1)
env.step(2)
env.seed()
env.reset()
env.close()
|
def test_order_id_generation():
Order._order_id_counter = 0
order1 = MarketOrder(1, TIME, 'X', 1, True)
order2 = MarketOrder(1, TIME, 'X', 1, True)
order3 = MarketOrder(1, TIME, 'X', 1, True)
assert (order1.order_id == 0)
assert (order2.order_id == 1)
assert (order3.order_id == 2)
Order._order_id_counter = 0
order1 = LimitOrder(1, TIME, 'X', 1, True, 1)
order2 = LimitOrder(1, TIME, 'X', 1, True, 1)
order3 = LimitOrder(1, TIME, 'X', 1, True, 1)
assert (order1.order_id == 0)
assert (order2.order_id == 1)
assert (order3.order_id == 2)
Order._order_id_counter = 0
order1 = MarketOrder(1, TIME, 'X', 1, True)
order2 = LimitOrder(1, TIME, 'X', 1, True, 1)
assert (order1.order_id == 0)
assert (order2.order_id == 1)
Order._order_id_counter = 0
order1 = MarketOrder(1, TIME, 'X', 1, True)
order2 = MarketOrder(1, TIME, 'X', 1, True, order_id=0)
order3 = MarketOrder(1, TIME, 'X', 1, True)
assert (order1.order_id == 0)
assert (order2.order_id == 0)
assert (order3.order_id == 1)
|
def test_order_equality():
order1 = LimitOrder(1, TIME, 'X', 1, True, 1)
order2 = LimitOrder(1, TIME, 'X', 1, True, 1)
assert (order1 == order1)
assert (order1 == deepcopy(order1))
assert (order1 != order2)
|
def test_base_order_init():
with pytest.raises(TypeError):
Order(1, TIME, 'X', 1, True)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.