def __init__(self): # TODO framework to test different parameter in parallel self.HZ = 14000.0 self.price_sum = 0 # perhaps make arg in Q(arg) an arg in __init__ self.prices = AutoQueue(10) self.price_sum_sq = 0 self.count = 0 self.boundary = 0.025 # percent change from mean
def __init__(self): self.HZ = 1.0 / 1.0 self.local_strategies = [self.tsla] # variables needed for tsla() self.prices = AutoQueue(10) self.boundary = 0.01 self.holding = False self.volume = 0
class LiveTestStrat(): """Same as Previous strat but this should use live prices and trade the same stratey as Strategy() """ def __init__(self): self.HZ = 1.0 / 1.0 self.local_strategies = [self.tsla] # variables needed for tsla() self.prices = AutoQueue(10) self.boundary = 0.01 self.holding = False self.volume = 0 def execute(self, portfolio): while True: for local_strategy in self.local_strategies: local_strategy() sleep(1.0 / self.HZ) def tsla(self): tsla = Security('TSLA') price = tsla.get_price() self.prices.put(price) volume = tsla.security.get_volume() # if volume != self.volume: # print(volume) # self.volume = volume # else: # return # do things necessary for avg and stddev calc # self.price_sum = self.prices.sum() # self.price_sum_sq = self.prices.sum_sq() # self.count = len(self.prices) avg = self.prices.average() var = self.prices.variance() if price < avg * (1 - self.boundary): # low price, want to buy while portfolio.buy(tsla, 1): pass self.holding = True elif price > avg * (1 + self.boundary): # high price, want to sell_all portfolio.sell_all(tsla) self.holding = False print( f'Price: {price:.2f}\tAvg: {avg:.2f}\tvar: {var:.2f} <{time.asctime()}', end='\r')
def __init__(self, udp_ip='127.0.0.1', udp_port='8888', message_size=16): super(InterfaceEvents, self).__init__() self.udp_ip = udp_ip self.udp_port = udp_port self.message_size = message_size self.list_events = AutoQueue(maxsize=250) self.list_events_time = AutoQueue(maxsize=250) self.lock = Lock() self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP self.sock.bind((self.udp_ip, self.udp_port)) # first message, with the sequence first_message, addr = self.sock.recvfrom( 4096) # buffer size is 1024 bytes self.frq_event, self.type_event, self.sequence_usage, self.sequence_training = self.decript_first_message( first_message)
def prepare_processes(self): list_queue = [ AutoQueue(maxsize=1) for _ in range(self.number_of_process) ] list_queue.append(AutoQueue(maxsize=100, autodrop=True)) # last queue has no limit self.queue_in = list_queue[0] self.queue_out = list_queue[-1] for i, process in enumerate(self.list_process_string): if isinstance(process, str): mod = __import__('pymuse.processes', fromlist=[process]) klass = getattr(mod, process) if self.list_params[i] is not None: self.list_process.append( klass(list_queue[i], list_queue[i + 1], self.list_params[i])) else: self.list_process.append( klass(list_queue[i], list_queue[i + 1])) else: process.queue_in = list_queue[i] process.queue_out = list_queue[i + 1] self.list_process.append(process)
class Strategy(): def __init__(self): # TODO framework to test different parameter in parallel self.HZ = 14000.0 self.price_sum = 0 # perhaps make arg in Q(arg) an arg in __init__ self.prices = AutoQueue(10) self.price_sum_sq = 0 self.count = 0 self.boundary = 0.025 # percent change from mean # calculate average using a queue, be able to set size using some parameter def execute(self, portfolio): goog = TestSecurity("GOOG") counter = 0 while counter < 949: price = goog.get_price() self.prices.put(price) # do things necessary for avg and stddev calc self.price_sum = self.prices.sum() self.price_sum_sq = self.prices.sum_sq() self.count = len(self.prices) avg = self.prices.average() var = self.prices.variance() if price < avg * (1 - self.boundary): # low price, want to buy while portfolio.buy(goog, 1): pass self.holding = True elif price > avg * (1 + self.boundary): # high price, want to sell_all portfolio.sell_all(goog) self.holding = False # print(f'Price: {price:.2f}\tAvg: {avg:.2f}\tvar: {var:.2f}') counter += 1 sleep(1.0 / self.HZ) print(portfolio)
class InterfaceEvents(Thread): def __init__(self, udp_ip='127.0.0.1', udp_port='8888', message_size=16): super(InterfaceEvents, self).__init__() self.udp_ip = udp_ip self.udp_port = udp_port self.message_size = message_size self.list_events = AutoQueue(maxsize=250) self.list_events_time = AutoQueue(maxsize=250) self.lock = Lock() self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP self.sock.bind((self.udp_ip, self.udp_port)) # first message, with the sequence first_message, addr = self.sock.recvfrom( 4096) # buffer size is 1024 bytes self.frq_event, self.type_event, self.sequence_usage, self.sequence_training = self.decript_first_message( first_message) def get_nearest_message(self): pass def start(self): super(InterfaceEvents, self).start() def decript_first_message(self, m): message_split_by_type = m.split(' DONE') split_message = message_split_by_type[0].split(' ') frq_event = split_message[0] type_event = split_message[1] sequence_usage = split_message[2:] sequence_training = None if type_event == 'T': sequence_training_list = message_split_by_type[1].split(' ')[1:] sequence_training = [[ sequence_training_list[2 * i], sequence_training_list[2 * i + 1].split(',') ] for i in range(len(sequence_training_list) / 2)] return frq_event, type_event, sequence_usage, sequence_training def add_event_synchronicity(self, time_event, event): self.lock.acquire() self.list_events.put(event) self.list_events_time.put(time_event) self.lock.release() def find_closest_event(self, datetime_window): event_usage, event_training = '', '' self.lock.acquire() list_events_time = list(self.list_events_time) list_events = list(self.list_events) self.lock.release() # search into the list of event and return the closest match index_closest_after = bisect_left(list_events_time, datetime_window) index_closest_before = index_closest_after - 1 # datetime are sorted in self.list_events_time datetime_before = list_events_time[index_closest_before] datetime_after = list_events_time[index_closest_before] index_event_before = list_events[index_closest_before] index_event_after = list_events[index_closest_before] # linear interpolation to find closest match percentage_closest = (datetime_window - datetime_before) / ( datetime_after - datetime_before) index_event_closest = index_event_before + percentage_closest * ( index_event_after - index_event_before) event_usage = self.sequence_usage[index_event_closest] # TODO: add extraction of usage for training return event_usage, event_training def refresh(self): while True: data, addr = self.sock.recvfrom( self.message_size) # buffer size is 1024 bytes # data is a message with the structure: # message: TEMPS_CLOCK,INDEX # exemple: 2017-03-20 19:05:45.191179,42 split_message = data.split(',') time_event = datetime.strptime(split_message[0], '%Y-%m-%d %H:%M:%S.%f') index_event = int(split_message[1]) event = self.sequence_usage[index_event] # add event to a list self.add_event_synchronicity(time_event, event)