def do_incoming_auth(event, message): global is_authed, connected_protoctl if (message.command == "PROTOCTL"): connected_protoctl = message elif (message.command == "PASS"): if (message.parameters[0] != config.get("Network/Password")): log.critical("Password mismatch! Expected '%s', got '%s'", config.get("Network/Password"), message.parameters[0]) Network.sendMsg( IRCMessage(':', config.get("Server/Name"), "ERROR", "Closing link: password mismatch")) #Network.disconnect() #this is done in the main file ffservices.shutdown(1) elif (message.command == "SERVER"): if (is_authed): return is_authed = True Server.addServer( Server.createServerFromMessage(message, connected_protoctl)) Event.trigger("Network/LinkEstablished") Network.isAuthed = True #anything that watches for this event should do things like send user info (NICK), #channel membership, channel info, modes, etc at this point Network.sendMsg( IRCMessage(None, None, "netinfo", 0, int(time.time()), ffservices.unrealProtocol, "*", 0, 0, 0, config.get("Network/Name"))) #TODO: keep track of my max known global users? Network.sendMsg(IRCMessage(None, None, "eos")) event.stop()
def load_session(file_path) -> Session: kick = Sample(name='kick', path='../../audio/kick.wav', spectral_position=SpectralPositions.low) perc = Sample(name='perc', path='../../audio/perc.wav', spectral_position=SpectralPositions.mid) hat = Sample(name='hat', path='../../audio/hat.wav', spectral_position=SpectralPositions.high) session = Session() session.add_sample(kick) session.add_sample(perc) session.add_sample(hat) time_signature = TimeSignature(4, 4, 4) session.change_time_signature(time_signature) session.change_tempo(120) for i in range(16): if i % 2 == 0: session.add_event(Event(sample=hat, time_stamp=i)) if i % 8 == 4: session.add_event(Event(sample=perc, time_stamp=i)) if i % 4 == 0: session.add_event(Event(sample=kick, time_stamp=i)) return session
def __init__(self,config): pygame.init() self.config = config self.running = True self.fullscreen = False self.framerate = config.framerate self.screen_height = config.WIN_HEIGHT self.screen_width = config.WIN_WIDTH self.screen_size = (self.screen_width,self.screen_height) self.run_menu = True self.run_fail_menu = False self.main_menu = MainMenu(config.WIN_WIDTH,config.WIN_HEIGHT) self.fail_menu = FailMenu(config.WIN_WIDTH,config.WIN_HEIGHT) self.screen = pygame.display.set_mode(self.screen_size) # list of level instances self.levels = [ Level_1(), Level_2(), Level_3(), Level_4() ] self.current_level = 0 self.space_controller = Space_Controller(self.config) self.platform_controller = Platform_Controller(self.config) self.event = Event() pygame.event.set_allowed([ pygame.QUIT,pygame.KEYDOWN, pygame.KEYUP]) self.level_type = ""
def disconnect(): global svr_sock, isConnected, isAuthed isConnected=False isAuthed=False Event.trigger("Network/Disconnect") if(svr_sock is None): return True svr_sock.close() return True
def disconnect(): global svr_sock, isConnected, isAuthed isConnected = False isAuthed = False Event.trigger("Network/Disconnect") if (svr_sock is None): return True svr_sock.close() return True
def connect(): global svr_sock, isConnected try: svr_sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM) svr_sock.connect((config.get("Network/Server"), config.get("Network/Port"))) isConnected=True except Exception as e: log.error("Failure to connect to server: %s:%d : %s", config.get("Network/Server"), config.get("Network/Port"), str(e)) return False Event.trigger("Network/Connect") return True
def handle(event): """ Event responder / handler """ try: if not isinstance(event, Event): raise Exception("Invalid event passed") logging.debug(f"Received Event: {event.name}") if event.name == Event.CONNECTION_TEST: event.client.connection.close() elif event.name == Event.MOVE_MOUSE: Mouse.move(event.value['x'], event.value['y']) x, y = Mouse.get_position() if x < 1: event_clipboard = Event(Event.CLIPBOARD, value=OS.get_clipboard_data(), client=event.client) event_clipboard.client.send_event(event_clipboard) event = Event(Event.CHANGE_POSITION, value=str(event.computer.get_position() - 1), client=event.client) event.client.send_event(event) elif event.name == Event.CHANGE_POSITION: event.computer.set_active_computer_position(int(event.value)) elif event.name == Event.MOUSE_LEFT_DOWN: Mouse.mouse.press(Button.left) elif event.name == Event.MOUSE_RIGHT_DOWN: Mouse.mouse.press(Button.right) elif event.name == Event.MOUSE_LEFT_UP: Mouse.mouse.release(Button.left) elif event.name == Event.MOUSE_RIGHT_UP: Mouse.mouse.release(Button.right) elif event.name == Event.MOUSE_WHEEL: Mouse.mouse.scroll(0, int(event.value) * MOUSE_SCROLL_SPEED) elif event.name == Event.KEY_DOWN: KeyBoard.keyboard.press(KeyCode.from_vk(event.value)) elif event.name == Event.KEY_UP: KeyBoard.keyboard.release(KeyCode.from_vk(event.value)) elif event.name == Event.CLIPBOARD: OS.set_clipboard_data(event.value) except Exception as e: logging.error("Error while handling event.") logging.exception(e)
def connect(): global svr_sock, isConnected try: svr_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) svr_sock.connect( (config.get("Network/Server"), config.get("Network/Port"))) isConnected = True except Exception as e: log.error("Failure to connect to server: %s:%d : %s", config.get("Network/Server"), config.get("Network/Port"), str(e)) return False Event.trigger("Network/Connect") return True
def test_sample_removing_does_remove_events(self): s1 = Sample(name='kick', path='kick.wav', spectral_position=SpectralPositions.low) s2 = Sample(name='snare', path='snare.wav', spectral_position=SpectralPositions.mid) self.session.add_sample(s1) self.session.add_sample(s2) self.session.add_event(Event(sample=s1, time_stamp=0)) self.session.add_event(Event(sample=s1, time_stamp=4)) self.session.add_event(Event(sample=s2, time_stamp=3)) self.assertEqual(self.listener.num_events, 3) self.assertEqual(self.listener.num_samples, 2) # now when s1 gets removed, the two events that use it should also get removed... self.session.remove_sample(s1) self.assertEqual(self.listener.num_samples, 1) self.assertEqual(self.listener.num_events, 1)
def get_next_batch(self, batch_size, fake_factor=None): """draw random batch according to random_sampler and fake events for triplet loss""" if fake_factor is None: fake_factor = self.cf.fake_frac eff_batch_size = min(batch_size, self.unique_train_event_cnt) self.new_epoch = False fake_batch_size = int(eff_batch_size * fake_factor) real_batch_size = eff_batch_size - fake_batch_size real_batch_events = self.get_random_events(real_batch_size) fake_batch_events = self.get_random_events(fake_batch_size) fake_batch_events_clone = [ Event(e.feature_idx, random.randint(0, self.im.total_interaction_cnt)) for e in fake_batch_events ] full_events = np.concatenate( (real_batch_events, fake_batch_events_clone), axis=0) features = self.im.idxs_to_tf([e.feature_idx for e in full_events]) labels = self.im.idxs_to_tf([e.label_idx for e in full_events]) target_distance = np.concatenate( (np.zeros(len(real_batch_events), np.float32), np.ones(len(fake_batch_events), np.float32)), axis=0) self._update_processed_state(eff_batch_size) return features, labels, target_distance
def test_event_removing(self): s = Sample(name='kick', path='kick.wav', spectral_position=SpectralPositions.low) self.session.add_sample(s) e = Event(sample=s, time_stamp=0) self.session.add_event(e) self.assertEqual(self.listener.num_events, 1) self.session.remove_event(e) self.assertEqual(self.listener.num_events, 0)
def run_strategy(self): """初始化 account_data""" if self.account: self.context.init_account(self.account) # todo: 如果是实时模式,则从数据库中取数据的结束时间为其中数据的最后时间, # 该时间与实时时间之间的数据再从数据api上取,补足到策略启动时 if self.run_mode == RunMode_LIVE: # self.end = pass # 从数据库读取数据 # todo: 现在先将所有数据都取到内存,以后为了减少内存占用,考虑以下方案: # 只将close读到内存,其他数据用到时才从数据库中取,以减少内存占用,交易次数不多的话,对速度的影响不大 # 而每个bar上都要用close计算账户净值,必须读入内存中 stk_all_list = self.universe + [self.benchmark] self.context.daily_data = self.get_data.get_all_market_data( stock_code=stk_all_list, field=self.fields, start=self.start, end=self.end, interval=Interval_DAILY) # 生成 benchmark 的 bar_index 数据 self.context.benchmark_index = [ datetime_to_timestamp(str(int(i)), '%Y%m%d') for i in self.context.daily_data["close"].loc[self.benchmark].index ] # 将benchmark的时间戳做成迭代器 bmi_iter = iter(self.context.benchmark_index) self.bar_index = 0 # self.event_engine.start() while True: # todo:以后外围包裹一个父函数,用来进行时间控制,只在交易时间内启动 try: cur_event = self.event_engine.get() except Empty: try: if self.run_mode == RunMode_BACKTESTING: # 回测模式下,市场数据通过生成器推送过来,并生成市场事件 self.timestamp = next(bmi_iter) self.datetime = timestamp_to_datetime(self.timestamp, format="%Y%m%d") event_market = Event(EVENT_BAR, self.datetime, self.gateway) self.event_engine.put(event_market) else: # todo: live模式下,市场数据通过api订阅后推送过来 pass except BacktestFinished: self.context.logger.info('策略运行完成') self.strategy_analysis() self.show_results() break else: # 监听/回调函数根据事件类型处理事件 self.event_engine.event_process(cur_event)
def test_adding_event(self): s = Sample(name='kick', path='kick.wav', spectral_position=SpectralPositions.low) e = Event(sample=s, time_stamp=0) self.session.add_event(e) # event can't be added, because the sample it uses is not in the session yet... self.assertEqual(self.listener.num_events, 0) self.session.add_sample(s) self.session.add_event(e) self.assertEqual(self.listener.num_events, 1) # adding the same event twice, should not result in two identical events, but just a single event self.session.add_event(e) self.assertEqual(self.listener.num_events, 1) # adding a different event should actually add e2 = Event(sample=s, time_stamp=1) self.session.add_event(e2) self.assertEqual(self.listener.num_events, 2)
def shutdown(self): try: event = Event(Event.SERVER_SHUT) for address in self.clients: self.clients[address].connection.sendall( EventEncoder.encode(event)) self.socket.close() except Exception as e: logging.error("Exception occurred on server shutdown.") logging.exception(e)
def run_backtesting(self): # 初始化 account_data if self.account: for account in self.account: Context.current_account_data = AccountData() Context.current_account_data.account_id = account Context.current_account_data.total_balance = self.account[ account] Context.current_account_data.available = self.account[account] Context.bar_account_data_list.append( Context.current_account_data) # 实时交易模式下,最后时间为数据库中基准标的物的最后时间戳(日) if self.run_mode == RunMode_LIVE: self.end = self.get_data.get_end_timetag(benchmark=self.benchmark, interval=Interval_DAILY) # 缓存数据,和bar_index的计算 stock_list = copy(self.universe) stock_list.append(self.benchmark) stock_list = list(set(stock_list)) if self.interval == Interval_DAILY: Context.daily_data = self.get_data.get_all_market_data( stock_code=stock_list, field=["open", "close"], start=self.start, end=self.end, interval=Interval_DAILY) Context.benchmark_index = [ datetime_to_timestamp(str(int(i)), '%Y%m%d') for i in Context.daily_data["close"].loc[self.benchmark].index if i >= self.start ] self.bar_len = len(Context.benchmark_index) # print(self.benchmark, self.start, self.end, self.interval, self.rights_adjustment, self.run_mode) bmi_iter = iter(Context.benchmark_index) self.bar_index = 0 self.strat_event_engine.start() while True: try: self.timestamp = next(bmi_iter) except Exception: # 回测完成 print('策略运行完成') break else: # 在历史数据上跑,以实时的形式回测。之所以用时间戳为索引,是统一时间轴格式 self.datetime = timestamp_to_datetime(self.timestamp, format="%Y%m%d") self.bar_index += 1 cur_event = Event(EVENT_BAR, self.datetime) self.strat_event_engine.put(cur_event)
def _run_timer(self): """运行在计时器线程中的循环函数""" while self._timer_active: # 创建计时器事件 event = Event(event_type=EVENT_TIMER) # 向队列中存入计时器事件 self.put(event) # 等待 sleep(self._timer_sleep)
def select(self, item): """Select an item from the KB. Args: item ({attribute_name: attribute_value}) Returns: SelectionEvent """ return Event.SelectionEvent(self.agent, item, time=self.timestamp())
def offer(self, offer, metadata=None): """Send an offer event. Args: offer ({'price': float, 'sides', str}) Returns: OfferEvent """ return Event.OfferEvent(self.agent, offer, time=self.timestamp(), metadata=None)
def reject(self, userid): try: with self.conn: cursor = self.conn.cursor() u = self._get_user_info_unchecked(cursor, userid) self._update_user(cursor, userid, connected_status=1) self.send(userid, Event.QuitEvent(u.agent_index, str(time.time()))) except sqlite3.IntegrityError: print("WARNING: Rolled back transaction") return None
def connect(self, host, port, computer): """" Connects on a server""" try: logging.info("Connecting to the server {}:{}".format(host, port)) self.server.socket_.connect((host, port)) self.server.connected = True event = Event(Event.TEST) self.server.socket_.send(EventEncoder.encode(event)) logging.info("Connected to the server.") self.event_receiver_thread(computer) except Exception as e: logging.error("Unable to connect to server.") logging.exception(e)
def do_incoming_auth(event, message): global is_authed, connected_protoctl if(message.command=="PROTOCTL"): connected_protoctl=message elif(message.command=="PASS"): if(message.parameters[0]!=config.get("Network/Password")): log.critical("Password mismatch! Expected '%s', got '%s'", config.get("Network/Password"), message.parameters[0]) Network.sendMsg(IRCMessage(':', config.get("Server/Name"), "ERROR", "Closing link: password mismatch")) #Network.disconnect() #this is done in the main file ffservices.shutdown(1) elif(message.command=="SERVER"): if(is_authed): return is_authed=True Server.addServer(Server.createServerFromMessage(message, connected_protoctl)) Event.trigger("Network/LinkEstablished") Network.isAuthed=True #anything that watches for this event should do things like send user info (NICK), #channel membership, channel info, modes, etc at this point Network.sendMsg(IRCMessage(None, None, "netinfo", 0, int(time.time()), ffservices.unrealProtocol, "*", 0, 0, 0, config.get("Network/Name"))) #TODO: keep track of my max known global users? Network.sendMsg(IRCMessage(None, None, "eos")) event.stop()
def decode(event): if not isinstance(event, str): raise Exception("Invalid json string passed.") try: event = event.replace("\"", "\\\"") event = event.replace("\'", "\"") json_ = json.loads(event) value = json_["value"] if json_["value"] else "" return Event(json_["name"], value) except (json.decoder.JSONDecodeError, KeyError) as e: logging.error("Invalid event passed. " + event) logging.exception(e) except Exception as e: logging.error("Unknown issue happened.") logging.exception(e)
def select(self, userid, idx): try: with self.conn: cursor = self.conn.cursor() u = self._get_user_info_unchecked(cursor, userid) scenario = self.scenario_db.get(u.scenario_id) kb = scenario.get_kb(u.agent_index) item = kb.items[idx] self.send(userid, Event.SelectionEvent(u.agent_index, item, str(time.time()))) return item except sqlite3.IntegrityError: print("WARNING: Rolled back transaction") return None
def _user_journey_to_events(self, journey_string): """journey_string needs to be comma separated integers, i.e., 15,35,37,38,...""" user_interaction = journey_string.split(",") events = [] for i in range(len(user_interaction) - 1): interaction = user_interaction[i] f_idx = int(interaction) for n in range(self.cf.neighboring_interactions + 1): if n + i > len(user_interaction) - 1: break interaction_plus_n = user_interaction[i + n] t_idx = int(interaction_plus_n) if f_idx is not t_idx: events.append(Event(f_idx, t_idx)) return events
def __is_server(host): """" Returns true if given host is a server """ try: socket.setdefaulttimeout(SERVER_CONNECT_TIMEOUT) socket_ = socket.socket(socket.AF_INET, socket.SOCK_STREAM) socket_.connect((host, PORT)) Interface.__active_server.append(host) event = Event(Event.CONNECTION_TEST) socket_.send(EventEncoder.encode(event)) socket_.close() logging.debug("Test connection to {}:{} closed.".format( host, PORT)) except socket.timeout: pass except ConnectionRefusedError: pass finally: socket.setdefaulttimeout(None)
def send_stop_order(self, dt, accnt, stock, direction, offset, price, volume, comments): self.context.stop_order_count += 1 stop_order = StopOrder(symbol=stock, exchange=get_exchange(stock), order_id=generate_random_id('stoporder'), direction=direction, offset=offset, price=price, order_volume=volume, account=accnt, order_datetime=dt, comments=comments) self.context.active_stop_orders[stop_order.order_id] = stop_order self.context.stop_orders[stop_order.order_id] = stop_order event_order = Event(EVENT_ORDER, dt, stop_order) self.event_engine.put(event_order)
def send_limit_order(self, dt, accnt, stock, direction, offset, price, volume, comments): self.context.limit_order_count += 1 order = OrderData(symbol=stock, exchange=get_exchange(stock), order_id=generate_random_id('order'), direction=direction, offset=offset, price=price, order_volume=volume, status=Status_SUBMITTING, account=accnt, gateway=self.gateway, order_datetime=dt, comments=comments) self.context.active_limit_orders[order.order_id] = order self.context.limit_orders[order.order_id] = order event_order = Event(EVENT_ORDER, dt, order) self.event_engine.put(event_order)
def convert_dictionary_to_event(dictionary: dict) -> Event: return Event(sample=convert_dictionary_to_sample(dictionary['sample']), time_stamp=dictionary['time_stamp'])
def done(self): return Event.DoneEvent(self.agent, time=self.timestamp())
def sendMsg(msg): global svr_sock Event.trigger("Message/Outgoing/"+msg.command, message=msg) return svr_sock.send(str(msg))
def cross_stop_order(self, event_market, cur_mkt_data): """处理未成交止损单""" print("-- this is deal_stop_order() @ {0}.".format(event_market.dt)) # 逐个未成交委托进行判断 for stop_order in list(self.context.active_stop_orders.values()): long_cross_price = cur_mkt_data['high'][stop_order.symbol] short_cross_price = cur_mkt_data['low'][stop_order.symbol] long_best_price = cur_mkt_data['open'][stop_order.symbol] short_best_price = cur_mkt_data['open'][stop_order.symbol] # 检查止损单是否能被触发 long_cross = (stop_order.direction == Direction_LONG and stop_order.price <= long_cross_price) short_cross = (stop_order.direction == Direction_SHORT and stop_order.price >= short_cross_price) # 如果委托单仍然不能被触发,则其所有状态都不改变,继续等待被触发 if not long_cross and not short_cross: continue # 否则新增一笔限价单(止损单在本地被触发后,最终以限价单形式发送到交易所) self.context.limit_order_count += 1 order = OrderData(symbol=stop_order.symbol, exchange=get_exchange(stop_order.symbol), order_id=generate_random_id('order'), direction=stop_order.direction, offset=stop_order.offset, price=stop_order.price, order_volume=stop_order.order_volume, filled_volume=stop_order.order_volume, status=Status_ALL_TRADED, account=stop_order.accnt, order_datetime=event_market.dt) self.context.limit_orders[order.order_id] = order # 更新stop_order对象的属性 # stop_order.order_ids.append(order.order_id) stop_order.filled_datetime = event_market.dt stop_order.status = StopOrderStatus_TRIGGERED # 未成交止损单清单中将本止损单去掉 if stop_order.order_id in self.context.active_stop_orders: self.context.active_stop_orders.pop(stop_order.order_id) # 止损单被触发,本地止损单转成限价单成交,新增order_event并送入队列中 event_order = Event(EVENT_ORDER, event_market.dt, order) self.event_engine.put(event_order) # 止损单被触发,新建一个成交对象 if long_cross: trade_price = max(stop_order.price, long_best_price) pos_change = order.order_volume else: trade_price = min(stop_order.price, short_best_price) pos_change = -order.order_volume self.context.trade_count += 1 trade = TradeData(symbol=order.symbol, exchange=order.exchange, order_id=order.order_id, trade_id=generate_random_id('filled'), direction=order.direction, offset=order.offset, price=trade_price, volume=order.order_volume, datetime=self.datetime, gateway=self.gateway) self.pos[trade.symbol] += pos_change # 新建成交事件,并推送到事件队列中 event_trade = Event(EVENT_TRADE, event_market.dt, trade) self.event_engine.put(event_trade) self.handle_trade(event_trade) self.context.trade_data_dict[trade.trade_id] = trade
def cross_limit_order(self, event_market, cur_mkt_data): """处理未成交限价单""" print("-- this is deal_limit_order() @ {0}".format(event_market.dt)) # 逐个未成交委托进行判断 for order in list(self.context.active_limit_orders.values()): long_cross_price = cur_mkt_data['low'][order.symbol] short_cross_price = cur_mkt_data['high'][order.symbol] long_best_price = cur_mkt_data['open'][order.symbol] short_best_price = cur_mkt_data['open'][order.symbol] # 委托状态从“待提交”转成“未成交“ if order.status == Status_SUBMITTING: order.status = Status_NOT_TRADED event_order = Event(EVENT_ORDER, event_market.dt, order) self.event_engine.put(event_order) # 检查限价单是否能被成交 long_cross = (order.direction == Direction_LONG and order.price >= long_cross_price > 0) short_cross = (order.direction == Direction_SHORT and order.price <= short_cross_price and short_cross_price > 0) # 如果委托单仍然不能被成交,则其所有状态都不改变,继续等待被成交 if not long_cross and not short_cross: continue # 委托单被成交了,状态改变成 filled order.filled_volume = order.order_volume order.status = Status_ALL_TRADED event_order = Event(EVENT_ORDER, event_market.dt, order) self.event_engine.put(event_order) self.context.active_limit_orders.pop(order.order_id) # 交易数量 + 1 self.context.trade_count += 1 if long_cross: trade_price = min(order.price, long_best_price) pos_change = order.order_volume else: trade_price = max(order.price, short_best_price) pos_change = -order.order_volume # 新建交易事件并送入事件驱动队列中 trade = TradeData(symbol=order.symbol, exchange=order.exchange, order_id=order.order_id, trade_id=generate_random_id('filled'), direction=order.direction, offset=order.offset, price=trade_price, volume=order.order_volume, datetime=event_market.dt, gateway=self.gateway) self.pos[trade.symbol] += pos_change event_trade = Event(EVENT_TRADE, event_market.dt, trade) self.event_engine.put(event_trade) self.handle_trade(event_trade) # 交易事件更新 self.context.trade_data_dict[trade.trade_id] = trade
import re, time sjoin_prefix_to_mode={"*":"q", "~":"a", "@":"o", "%":"h", "+":"v", "&":"b", "\"":"E", "'":"I"} #logically, SAJOIN, SAPART, and SAMODE should be implemented here. However, as this #is a services server, we should never receive them from a server -- if we do they #would be targeted at one of our clients and should be ignored anyway. #INVITE should be implemented here as well -- probably not though, since we don't need to respond to invites ourself def module_start(): return True def module_stop(): return True Event.listen("Message/Incoming/SJOIN") def handle_sjoin(event, message): chan_name=message.parameters[1] timestamp=message.parameters[0] chan=Channel.findByName(chan_name) if(chan is None): chan=Channel(chan_name, timestamp) Channel.addChannel(chan) p_idx=2 if(message.parameters[p_idx][0]=="+"): #we have modes if(chan.timestamp==timestamp): #merge modes chan.setModes(message.parameters[p_idx], message.parameters[p_idx+1:-1], True) elif(chan.timestamp>timestamp): #clear existing modes and use sjoin modes
def test_find_highest_time_stamp_in_event_list(self): time_stamps = [1, 2, 3, 7, 5, 6, 74, 3, 5, 4] events = [Event(sample=None, time_stamp=t) for t in time_stamps] highest_time_stamp = find_highest_time_stamp_in_event_list(events) self.assertEqual(max(time_stamps), highest_time_stamp)
def receive_quit(self): e = Event.QuitEvent(self.agent ^ 1, time=self.timestamp()) self.receive(e)