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)
