def parse_command(s: str):
if cli_handler is None:
__setup_handler()
lines = s.strip().split(';')
for l in lines:
args = l.strip().split(' ')
nargs = len(args)
found = False
print('Searching for {}'.format(args[0]))
for c in commands:
if args[0] == c.title:
print('Found {}'.format(args[0]))
data = c.parse(args[1:] if len(args) > 1 else [])
c.handle(cli_handler, data)
found = True
if not found:
print('{} not found, executing as json message'.format(args[0]))
if nargs == 1:
cli_handler.send(Message(args[0]))
elif nargs == 2:
cli_handler.send(Message(args[0], args[1]))
elif nargs == 3:
cli_handler.send(Message(args[0], args[1],
json.loads(args[2])))
def check_triggers(self):
for i, s in enumerate(self.stocks):
if self.limits[s.acronym].check_buy(self.history[i].bid_price,
s.ask_price):
self.handler.send(Message('trade_control', 'buy', s))
elif self.limits[s.acronym].check_sell(self.history[i].ask_price,
s.bid_price):
self.handler.send(Message('trade_control', 'sell', s))
def test_config_filename(self):
self.client.send(
Message('json_config', 'filename', '/tmp/robin_test_2/'))
self.client.send(Message('json_request', 'save'))
time.sleep(1)
self.assertTrue(
path.exists(path.join('/tmp/robin_test_2/', state_save_file)),
'Modifying filename, configures to save in new location')
def test_remove_stock(self):
self.client.send(Message('vault_request', 'add_monitor',
Stock('AAPL')))
self.client.send(
Message('vault_request', 'remove_monitor', Stock('AAPL')))
time.sleep(0.5)
names = StockVault.get_stock_names()
self.assertTrue('AAPL' not in names,
'A removed stock should not appear in the database')
def test_config_count(self):
self.client.send(Message('json_config', 'count', 2))
second_uut = TestQSM('test2')
second_uut.start()
self.client.send(Message('json_request', 'save'))
time.sleep(1)
data = JSONController.load(output_directory)
self.assertTrue(
len(data) == 3,
"Modifying the count value should've generated three controllers, not {}"
.format(len(data)))
def sell_stock(self, s: ManagedStock):
self.balance += s.bid_price * s.shares
self.handler.send(
Message('trade_balance_update', self.name,
BalanceUpdate(self.balance)))
self.handler.send(
Message(
'trade', self.name,
StockTransaction(s.acronym, False, s.bid_price, s.ask_price,
s.shares)))
print("Selling {}".format(s))
def buy_stock(self, s: ManagedStock):
if self.balance >= s.ask_price * s.shares:
self.handler.send(
Message('trade_balance_update', self.name,
BalanceUpdate(self.balance)))
self.handler.send(
Message(
'trade', self.name,
StockTransaction(s.acronym, True, s.bid_price, s.ask_price,
s.shares)))
print("Buying {}".format(s))
else:
print('Rejecting transaction, insufficient funds')
def handle(self, handler: MessageHandler, data: dict) -> None:
handler.send(
Message(
'vault_request', 'add_stock',
ManagedStock(data['acronym'],
last_price=float(data['price']),
shares=int(data['shares']))))
def all_msg(self, msg: Message):
if msg.msg == 'save':
self.handler.send(Message('json_update', self.name, {'dtype': str(type(self).__name__),
'package': inspect.getmodulename(
inspect.getfile(self.__class__)),
'path': str(inspect.getfile(self.__class__)),
'data': self.dict}))
def test_add_stock(self):
self.client.send(Message('vault_request', 'add_monitor',
Stock('AAPL')))
time.sleep(0.5)
names = StockVault.get_stock_names()
print(names)
self.assertTrue('AAPL' in names,
'An inserted stock should appear in the database')
def test_get_info(self):
self.client.send(Message('vault_request', 'add_monitor',
Stock('AAPL')))
time.sleep(0.1)
info = StockVault.get_info('AAPL')
self.assertTrue(
info.acronym == 'AAPL',
'Inserted database element should be able to be found by info grab'
)
def test_save(self):
self.client.send(Message('json_request', 'save'))
time.sleep(1)
self.assertTrue(
path.exists(path.join(output_directory, state_save_file)),
'Saving generates a state file')
self.assertTrue(
path.getsize(path.join(output_directory, state_save_file)) > 0,
'Saving should populate file')
def get_stock_ids() -> list:
if StockVault.instance is None:
StockVault.setup_instance()
StockVault.instance.req_lock.acquire()
print('Acquired lock')
StockVault.instance.requestq.put(Message('request', 'get_stock_ids'))
print('Waiting for response')
results = StockVault.instance.req_out.get()
StockVault.instance.req_lock.release()
return results
def add_stock(s: ManagedStock) -> int:
if StockVault.instance is None:
StockVault.setup_instance()
StockVault.instance.req_lock.acquire()
# print('Acquired lock')
StockVault.instance.requestq.put(Message('request', 'add_stock', s))
# print('Waiting for response')
result = StockVault.instance.req_out.get()
StockVault.instance.req_lock.release()
return result
def get_info(acronym: str) -> Stock:
if StockVault.instance is None:
StockVault.setup_instance()
StockVault.instance.req_lock.acquire()
# print('Acquired lock')
StockVault.instance.requestq.put(
Message('request', 'get_info', acronym))
# print('Waiting for response')
result = StockVault.instance.req_out.get()
StockVault.instance.req_lock.release()
return result
def test_load(self):
self.client.send(Message('json_request', 'save'))
time.sleep(1)
data = JSONController.load(output_directory)
self.assertTrue(
len(data) == 2, "Loading should've created two controllers")
found = False
for d in data:
if d.name == 'test':
found = True
self.assertTrue(found,
"TestQSM should've been loaded by the controller")
def update_prices(self):
for s in self.stocks:
quote = self.adapter.get_quote(s.acronym)
prev_ask = s.ask_price
prev_bid = s.bid_price
s.ask_price = float(quote['ask_price'])
s.bid_price = float(quote['bid_price'])
print('Updated {}'.format(s))
if prev_ask != s.ask_price or prev_bid != s.bid_price:
self.handler.send(
Message(
'monitor_update', self.name,
StockUpdate(-1, s.acronym, s.ask_price,
int(quote['ask_size']), s.bid_price,
int(quote['bid_size']))))
self.append_state('check_triggers')
def __add_stock(self, msg: Message):
if self.is_connected:
monitors = execute_read_query(self.connection,
'select acronym from Stocks')
monitors = [m[0] for m in monitors] if monitors is not None else []
if msg.payload.acronym not in monitors:
print('Adding monitor for {} as well'.format(
msg.payload.acronym))
self.requestq.put(
Message('vault_request', 'add_monitor',
Stock(msg.payload.acronym)))
ins_str = setup_record_insertion('ManagedStocks',
ManagedStock.get_tuple_names(),
[msg.payload.to_tuple_str()])
execute_query(self.connection, ins_str)
def add_stocks(self, msg: Message):
if self.is_connected:
monitors = execute_read_query(self.connection,
'select acronym from Stocks')
monitors = [m[0] for m in monitors] if monitors is not None else []
needs_adding = []
for a in msg.payload:
if a.acronym not in monitors:
print('Adding monitor for {} as well'.format(a.acronym))
needs_adding.append(Stock(a.acronym))
self.requestq.put(
Message('vault_request', 'add_monitors', needs_adding))
ins_str = setup_record_insertion(
'ManagedStocks', ManagedStock.get_tuple_names(),
[r.to_tuple_str() for r in msg.payload])
execute_query(self.connection, ins_str)
def handle(self, handler: MessageHandler, data: dict) -> None:
trans = StockTransaction(data['id'], '', True, data['price'],
data['shares'])
trans.date = dt.datetime.strptime(data['date'], date_format)
handler.send(Message('vault_request', 'add_transaction', trans))
def handle(self, handler: MessageHandler, data: dict) -> None:
handler.send(Message('all', 'load'))
def exit_state(self):
self.handler.send(Message('EXIT'))
for m in self.modules:
m.join()
self.handler.join()
super().exit_state()
def handle(self, handler: MessageHandler, data: dict) -> None:
if data['title'] == 'force':
handler.send(Message('monitor_config', 'update'))
else:
super().handle(handler, data)
def initial_state(self):
self.handler.send(Message('test'))
print('Sent test message')
def handle(self, handler: MessageHandler, data: dict) -> None:
handler.send(Message('vault_request', 'remove_stock', ManagedStock('None', data['id'], data['shares'])))
def save(self):
self.buffer.clear()
self.handler.send(Message('all', 'save'))
def handle(self, handler: MessageHandler, data: dict) -> None:
up = BalanceUpdate(data['amount'])
up.date = dt.datetime.strptime(data['date'], date_format)
handler.send(Message('vault_request', 'add_balance_update', up))
def handle(self, handler: MessageHandler, data: dict) -> None:
handler.send(Message('monitor_config', 'add', Stock(data['acronym'])))
def handle(self, handler: MessageHandler, data: dict) -> None:
handler.send(Message('monitor_config', 'limit', data['limit']))
second_uut.start()
self.client.send(Message('json_request', 'save'))
time.sleep(1)
data = JSONController.load(output_directory)
self.assertTrue(
len(data) == 3,
"Modifying the count value should've generated three controllers, not {}"
.format(len(data)))
if __name__ == '__main__':
# unittest.main()
uut = TestQSM()
uut.start()
jcontr = JSONController('test_json', output_directory, 1)
jcontr.start()
client = MessageHandler('client')
client.send(Message('json_request', 'save'))
time.sleep(1)
data = JSONController.load(output_directory)
assert len(data) == 2
found = False
for d in data:
if isinstance(d, TestQSM):
found = True
assert found
