# send to IB
id = self._api.placeOrder(ibcontract, iborder)
# update order id
order.id = id
self._orders[order.id] = order
# set event for later trigerring
self._order_received_map[id] = asyncio.Event()
await self._order_received_map[id] # type: ignore
res = self._order_received_res[id]
del self._order_received_map[id]
del self._order_received_res[id]
return res
async def cancelOrder(self, order: AATOrder) -> bool:
"""cancel a previously submitted order to the exchange.
For MarketData-only, can just return None
"""
self._api.cancelOrder(order)
res = self._order_cancelled_res[order.id]
del self._order_cancelled_map[order.id]
del self._order_cancelled_res[order.id]
return res
Exchange.registerExchange("ib", InteractiveBrokersExchange)
price=order.price,
size=order.volume,
time_in_force=time_in_force)
elif order.type == OrderType.MARKET:
ret = self._auth_client.place_limit_order(
product_id='{}-{}'.format(order.instrument.leg1.name,
order.instrument.leg2.name),
side=order.side.value.lower(),
funds=order.price * order.volume)
elif order.type == OrderType.STOP:
# TODO
raise NotImplementedError()
# self._auth_client.place_stop_order(product_id='BTC-USD',
# side='buy',
# price='200.00',
# size='0.01')
# Set ID
order.id = ret['id']
return order
async def cancelOrder(self, order: Order):
'''cancel a previously submitted order to the exchange.'''
self._auth_client.cancel_order(order.id)
return order
Exchange.registerExchange('coinbase', CoinbaseProExchange)
return self._account_position_queue.get()
else:
await asyncio.sleep(1)
i += 1
async def newOrder(self, order):
'''submit a new order to the exchange. should set the given order's `id` field to exchange-assigned id
For MarketData-only, can just return None
'''
# construct IB contract and order
ibcontract, iborder = _constructContractAndOrder(order)
# send to IB
id = self._api.placeOrder(ibcontract, iborder)
# update order id
order.id = id
self._orders[order.id] = order
async def cancelOrder(self, order: Order):
'''cancel a previously submitted order to the exchange.
For MarketData-only, can just return None
'''
self._api.cancelOrder(order.id)
Exchange.registerExchange('ib', InteractiveBrokersExchange)
self._filename = filename
self._data: List[Trade] = []
self._value_field = value_field
async def instruments(self):
'''get list of available instruments'''
return list(set(_.instrument for _ in self._data))
async def connect(self):
with open(self._filename) as csvfile:
self._reader = csv.DictReader(csvfile, delimiter=',')
for row in self._reader:
if self._value_field:
value = row[self._value_field]
if 'value' in row:
value = row['value']
elif 'price' in row:
value = row['price']
elif 'close' in row:
# OHLC data
value = row['close']
else:
raise Exception('Must provide a value field or "value", "price", "close"')
_ = value
# TODO make this smarter or more configureable
Exchange.registerExchange('csv', CSV)
# First, roll through order book snapshot
for item in self._client.orderBook(self._subscriptions):
yield item
# then stream in live updates
async for tick in self._client.websocket(self._subscriptions):
yield tick
async def subscribe(self, instrument):
# can only subscribe to pair data
if instrument.type == InstrumentType.PAIR:
self._subscriptions.append(instrument)
# ******************* #
# Order Entry Methods #
# ******************* #
async def accounts(self):
"""get accounts from source"""
return self._client.accounts()
async def newOrder(self, order):
"""submit a new order to the exchange. should set the given order's `id` field to exchange-assigned id"""
await self._client.newOrder(order)
async def cancelOrder(self, order: Order):
"""cancel a previously submitted order to the exchange."""
await self._client.cancelOrder(order)
Exchange.registerExchange("coinbase", CoinbaseProExchange)
order.timestamp = timestamp
order.filled = order.volume
t = Trade(
volume=order.volume,
price=order.price,
taker_order=order,
maker_orders=[],
my_order=order,
)
yield Event(type=EventType.TRADE, target=t)
await asyncio.sleep(0)
async def cancelOrder(self, order: Order) -> bool:
# Can't cancel, orders execute immediately
# TODO limit orders
return False
async def newOrder(self, order: Order) -> bool:
if self._trading_type == TradingType.LIVE:
raise NotImplementedError("Live OE not available for CSV")
order.id = str(self._order_id)
self._order_id += 1
self._queued_orders.append(order)
return True
Exchange.registerExchange("csv", CSV)
from aat.exchange import Exchange
from aat.core import ExchangeType
class Kafka(Exchange):
'''Kafka Exchange'''
def __init__(self, trading_type, verbose):
super().__init__(ExchangeType('kafka'))
self._trading_type = trading_type
self._verbose = verbose
Exchange.registerExchange('kafka', Kafka)
from aat.exchange import Exchange
from aat.core import ExchangeType
class Kafka(Exchange):
"""Kafka Exchange"""
def __init__(self, trading_type, verbose):
super().__init__(ExchangeType("kafka"))
self._trading_type = trading_type
self._verbose = verbose
Exchange.registerExchange("kafka", Kafka)
maker_orders=[],
my_order=order,
)
yield Event(type=EventType.TRADE, target=t)
await asyncio.sleep(0)
# ******************* #
# Order Entry Methods #
# ******************* #
async def newOrder(self, order: Order) -> bool:
"""submit a new order to the exchange. should set the given order's `id` field to exchange-assigned id
For MarketData-only, can just return None
"""
if self._trading_type == TradingType.LIVE:
raise NotImplementedError("Live OE not available for IEX")
order.id = str(self._order_id)
self._order_id += 1
self._queued_orders.append(order)
return True
async def cancelOrder(self, order: Order) -> bool:
# Can't cancel, orders execute immediately
# TODO limit orders
return False
Exchange.registerExchange("iex", IEX)
t = Trade(volume=order.volume,
price=order.price,
taker_order=order,
maker_orders=[])
t.my_order = order
yield Event(type=EventType.TRADE, target=t)
await asyncio.sleep(0)
# ******************* #
# Order Entry Methods #
# ******************* #
async def newOrder(self, order: Order):
'''submit a new order to the exchange. should set the given order's `id` field to exchange-assigned id
For MarketData-only, can just return None
'''
if self._trading_type == TradingType.LIVE:
raise NotImplementedError("Live OE not available for IEX")
order.id = self._order_id
self._order_id += 1
self._queued_orders.append(order)
return order
# Not implemented, data-only
Exchange.registerExchange('iex', IEX)
