def process(self, iEv):
"""Run event processing for all analyzers in the sequence.
This function is called by self.loop,
but can also be called directly from
the python interpreter, to jump to a given event.
"""
self.event = Event(iEv, self.events[iEv])
self.iEvent = iEv
for analyzer in self.analyzers:
if not analyzer.beginLoopCalled:
analyzer.beginLoop()
if analyzer.process(self.event) == False:
return (False, analyzer.name)
return (True, analyzer.name)
def clear_app(self, event_count):
for device in self.devices:
device.clear_app(self.app, self.is_login_app)
device.use.set_orientation("n")
for device in self.guest_devices:
device.error_event_lists.clear()
device.wrong_event_lists.clear()
device.wrong_flag = True
self.utils.write_read_event(
"::clear::all devices::None::None" + '\n', event_count, None,
"all devices", device.device_num)
event = Event(None, "clear", device, event_count)
self.utils.write_event(event, device.device_num, device.f_trace)
self.utils.draw_event(event)
def post_init(self):
weather2 = Event('__.weather2__')
weather2.define(msg_definition=r'^\.weather |^\.w ',
case_insensitive=True)
weather2.subscribe(self)
self.bot.register_event(weather2, self)
self.bing_api_url = "http://dev.virtualearth.net/REST/v1/Locations?query="
self.bing_api_key_string = "&key=AuEaLSdFYvXwY4u1FnyP-f9l5u5Ul9AUA_U1F-eJ-8O_Fo9Cngl95z6UL0Lr5Nmx"
self.api_key = "6dc001f4e77cc0985c5013283368be51"
self.api_url = "https://api.openweathermap.org/data/2.5/weather"
self.headers = {
'user-agent':
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36',
}
def processTradeEvent(self, event):
"""处理成交推送"""
# 检查成交是否需要处理
trade = event.dict_['data']
if trade.vtSymbol not in self.legDict:
return
# 更新腿持仓
leg = self.legDict[trade.vtSymbol]
direction = trade.direction
offset = trade.offset
if direction == DIRECTION_LONG:
if offset == OFFSET_OPEN:
leg.longPos += trade.volume
else:
leg.shortPos -= trade.volume
else:
if offset == OFFSET_OPEN:
leg.shortPos += trade.volume
else:
leg.longPos -= trade.volume
leg.netPos = leg.longPos - leg.shortPos
# 更新价差持仓
spread = self.vtSymbolSpreadDict[trade.vtSymbol]
spread.calculatePos()
# 推送价差持仓更新
event1 = Event(EVENT_SPREADTRADING_POS + spread.name)
event1.dict_['data'] = spread
self.eventEngine.put(event1)
event2 = Event(EVENT_SPREADTRADING_POS)
event2.dict_['data'] = spread
self.eventEngine.put(event2)
def init_order_arrival_events(n):
""" initialises and returns a list of order arrival events to process in the simulation engine
(right now takes in just a parameter n, number of orders, but can take in distributions in the future) """
order_event_list = []
for i in range(n):
time = random.randint(0, LAST_ORDER_TIME)
new_event = Event(
{
'order': Order(time),
'event_time': time,
'event_type': 'ARRIVAL'
}, check_completed)
order_event_list.append(new_event)
return order_event_list
def transmit_next_packet(self):
assert(self.state == self.TX)
assert(len(self.queue) > 0)
packet_size = self.dequeue_packet_size()
duration = packet_size * 8 / self.datarate
# transmit packet
tx_packet = Packet(packet_size, duration)
self.channel.start_transmission(self, tx_packet)
# schedule end of transmission
end_tx = Event(self.sim.get_time() + duration, Events.END_TX, self,
self, tx_packet)
self.sim.schedule_event(end_tx)
def __init__(self, events=None, printer_handle=None, bot=None, say=None):
self.events = events
self.printer = printer_handle
self.bot = bot
self.interests = []
self.say = say
self.cmd = None
self.help = None
mod = Event("__.module__")
mod.define(msg_definition="^\\.module ")
mod.subscribe(self)
self.bot.register_event(mod, self)
def post_init(self):
uptime_event = Event("__.uptime__")
uptime_event.define(msg_definition="^\\.uptime")
uptime_event.subscribe(self)
self.help = ".uptime (spits out uptime)"
# register ourself to our new custom event
self.bot.register_event(uptime_event, self)
starttime = time.time()
localtime = time.localtime()
if 'uptime' not in self.bot.mem_store:
self.bot.mem_store['uptime'] = dict()
self.bot.mem_store['uptime']['localtime'] = localtime
self.bot.mem_store['uptime']['starttime'] = starttime
def remove_frame(self):
entity = self.context['selected_entity']
selected_index = self.frame_list_view.currentRow()
selected_frame = self.frame_list_view.takeItem(selected_index)
# remove the frame from its parent animation
frame_component = selected_frame.component
self.selected_animation.component.frames.remove(frame_component)
# fire event
new_event = Event('removed_component',
entity=entity,
component_type='frame',
component=frame_component)
EVENT_MANAGER.fire_event(new_event)
def tick(self, dt):
events = [
Event(EVENT_ID_GENERATOR.get(),
self.objects["scenario"][0],
"date",
self.objects["scenario"][0].date.isoformat(),
(self.objects["scenario"][0].date + dt).isoformat()
)
]
self.objects["scenario"][0].date += dt
for flight in self.objects["flight"]:
events += update_flight_status(flight, self.objects["scenario"][0].date)
# it's the job of the server to handle these events
return events
def post_event(self, e):
"""
add event to the queue
"""
self.lock.acquire()
try:
if not isinstance(e, Event):
self.queue += [Event(e, context=self.context)]
else:
self.queue += [e]
finally:
self.lock.release()
if self.event_callback:
self.event_callback()
def save_to_db(self):
self.time = datetime.datetime.now()
with ConnectionPool() as cursor:
cursor.execute(
'INSERT INTO comment_table(owner,time,comment,subject,event_id,is_edited,send_notification) VALUES(%s,%s,%s,%s,%s,%s,%s)',
(self.owner, self.time, self.comment, self.subject,
self.event_id, self.is_edited, self.send_notification))
if self.send_notification:
event = Event(None, None, None, None, None, None, None)
event.read_with_id(self.event_id)
for participant in event.participant_arr:
new = New(None, self.owner, participant, event.group_id,
self.event_id, None, 'event', 'commented', False,
None, None)
new.save_to_db()
def slack_event():
logging.debug("Request payload: %s", request.data)
event = request.get_json()
if 'token' not in event:
logging.error(
"There is no verification token in the JSON, discarding event")
abort(401)
if event['token'] != verification_token:
logging.error("Wrong verification token in JSON, discarding event")
abort(403)
if 'challenge' in event:
return jsonify({'challenge': event['challenge']})
else:
bot.handle_event(Event(event))
return jsonify({})
def plot_hist_time_between_event(file_name, N):
f = SimpleFile(os.path.join("..", "data", file_name))
time = np.zeros(N)
diff_time = np.zeros(N - 1)
for i in range(1, N - 1):
ev = next(f.Events)
Ev = Event(ev)
Ev.read()
time[i] = Ev.local133MHzClockCounter / (133 * 1e6)
diff_time[i] = time[i] - time[i - 1]
plt.hist(diff_time[2:], bins=15)
plt.title(file_name)
plt.show()
return diff_time
def get_orders_from_file():
"""function that gets the initial orders from a json file"""
global NUM_ORDERS
input_file = open("test_orders.json")
x = json.load(input_file)
orders = [
Event(
{
'order': Order(order["ts"], order["ingredients"]),
'event_time': order["ts"],
'event_type': 'ARRIVAL'
}, check_completed) for order in x["orders"]
]
NUM_ORDERS = len(orders)
return orders
def addEvent(self, raw_event):
# do not call the method saveDocument, instead, call this method
# add an event to the db. raw_event can either be a json or an instance of Event
if not type(raw_event) is types.DictType:
new_event = raw_event.toJSON()
else:
new_event = raw_event
new_event = Event(new_event)
new_event.sortPhotos()
new_event = new_event.toJSON()
# before adding, find if any event can be merged
condition = {'region': new_event['region']}
# condition = {'lat':new_event['lat'], 'lng':new_event['lng']}
old_events = self.getAllDocuments(condition).sort('created_time', -1)
for old_event in old_events:
end_time1 = int(new_event['photos'][0]['created_time'])
begin_time1 = int(new_event['photos'][-1]['created_time'])
end_time2 = int(old_event['photos'][0]['created_time'])
begin_time2 = int(old_event['photos'][-1]['created_time'])
time_interval = InstagramConfig.merge_time_interval
if end_time1 + time_interval >= begin_time2 and end_time2 + time_interval >= begin_time1:
# if can merge
merged_event = Event(old_event)
merged = merged_event.mergeWith(new_event)
if merged >= 0:
print '%d out of %d photos are merged into an old event' % (
merged, len(new_event['photos']))
# print old_event['_id'], new_event['_id']
if merged > 0:
self.updateDocument(merged_event)
return
# cannot merge
print 'create a new event'
super(EventInterface, self).saveDocument(new_event)
def back_to_app(self, event_count, strategy):
for device in self.devices:
device.use.press("back")
print("Back")
time.sleep(self.rest_interval * 1)
if not self.checker.check_foreground():
for device in self.devices:
device.stop_app(self.app)
args = (self.app, )
device.set_thread(device.start_app, args)
self.utils.start_thread()
self.checker.check_start(1, strategy)
for device in self.guest_devices:
self.utils.write_read_event(
"::restart::all devices::None::None" + '\n', event_count,
None, "all devices", device.device_num)
event = Event(None, "back", device, event_count)
self.utils.write_event(event, device.device_num,
device.f_trace)
event = Event(None, "home", device, event_count)
self.utils.write_event(event, device.device_num,
device.f_trace)
event = Event(None, "start", device, event_count)
self.utils.write_event(event, device.device_num,
device.f_trace)
self.utils.draw_event(event)
else:
for device in self.guest_devices:
self.utils.write_read_event(
"::back::all devices::None::None" + '\n', event_count,
None, "all devices", device.device_num)
event = Event(None, "back", device, event_count)
self.utils.write_event(event, device.device_num,
device.f_trace)
self.utils.draw_event(event)
def check_available_tickets(update, personCount):
event = Event()
if personCount < 1:
update.message.reply_text('Sorry but ghosts aren\'t invited.')
return False
elif (event.maxTickets - sum(event.guests.values())) - personCount < 0:
update.message.reply_text(
'There are only ' +
str(event.maxTickets - sum(event.guests.values())) +
' available. How many of these tickets do you want to book?')
return False
else:
return True
def transmit_packet(self, packet_size):
"""
Generates, sends, and schedules end of transmission of a new packet
:param packet_size: size of the packet to send in bytes
"""
assert (self.current_pkt is None)
duration = packet_size * 8 / self.datarate
# transmit packet
packet = Packet(packet_size, duration)
self.channel.start_transmission(self, packet)
# schedule end of transmission
end_tx = Event(self.sim.get_time() + duration, Events.END_TX, self,
self, packet)
self.sim.schedule_event(end_tx)
self.current_pkt = packet
def __init__(self):
self.deck = Deck()
self.players = list()
self.game_event = Event()
self.card_played = Event()
self.cards_taken = Event()
self.player_added = Event()
self.colour_decision_made = Event()
self.cant_play = Event()
def _run(self):
logger.debug('Starting ovpn process. %r' % {
'server_id': self.id,
})
self._interrupt = False
try:
threading.Thread(target=self._status_thread).start()
try:
process = subprocess.Popen(['openvpn', self.ovpn_conf_path],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
_process[self.id] = process
except OSError:
_output[self.id] += traceback.format_exc()
self._event_delay(type=SERVER_OUTPUT_UPDATED,
resource_id=self.id)
logger.exception('Failed to start ovpn process. %r' % {
'server_id': self.id,
})
return
while True:
line = process.stdout.readline()
if line == '' and process.poll() is not None:
break
_output[self.id] += line
self._event_delay(type=SERVER_OUTPUT_UPDATED,
resource_id=self.id)
logger.debug('Ovpn process has ended. %r' % {
'server_id': self.id,
})
finally:
self._interrupt = True
try:
del _threads[self.id]
except KeyError:
pass
try:
del _process[self.id]
except KeyError:
pass
try:
del _start_time[self.id]
except KeyError:
pass
Event(type=SERVERS_UPDATED)
def __init__(self, object_id, name, env, bw):
""" Constructor for Rate_Graph class
"""
self.name = name
self.env = env
self.bw = bw
self.object_id = object_id
self.window_size = 1000
self.window = PriorityQueue()
self.bits_in_window = 0
# Interval between points
self.interval = 100
self.env.add_event(Event("Graph rate",
self.object_id,
self.graph),
self.window_size)
def test_execute_with_exce_execute_cmd(self, m_error):
m_file = mock_open(read_data=''.join('cmd1'))
m_file.return_value.__iter__ = lambda self: self
m_file.return_value.__next__ = lambda self: next(
iter(self.readline, ''))
with patch('builtins.open', m_file):
mock = MagicMock()
mock.args.tick_duration = 0
e = Event(mock)
e._execute_cmd = MagicMock()
e._execute_cmd.side_effect = Exception('mock')
e.execute()
self.assertRegex(m_error.call_args[0][0],
'Simulation could not .*')
def dispatcher_func(self, cur_process):
# run for the least remaining time
run_time = Process.run_for(cur_process, cur_process.remaining_time,
self.time)
event_TYPE = EventTypes.PROC_CPU_DONE
if (run_time == cur_process.remaining_time):
cur_process.process_state = ProcessStates.TERMINATED
else:
cur_process.process_state = ProcessStates.READY
event_TYPE = EventTypes.PROC_CPU_REQ
self.processes.append(cur_process)
event_run = Event(process_id=cur_process.process_id,
event_type=event_TYPE,
event_time=self.time)
return event_run
def dispatcher_func(self, cur_process):
# run for a fixed quantum of 0.5 ms
run_time = Process.run_for(cur_process, 0.5, self.time)
event_TYPE = EventTypes.PROC_CPU_DONE
# if it completed, state=terminated, else state=ready and put process back in queue
if (run_time == cur_process.remaining_time):
cur_process.process_state = ProcessStates.TERMINATED
else:
cur_process.process_state = ProcessStates.READY
event_TYPE = EventTypes.PROC_CPU_REQ
self.processes.append(cur_process)
event_run = Event(process_id=cur_process.process_id,
event_type=event_TYPE,
event_time=self.time)
return event_run
def load_events(self):
try:
with open(self.filepath, 'r') as f:
events = json.load(f)
result = []
for event in events:
#Need to update result to event details.
levent = Event(event['id'], int(event['creator']),
event['chan'], event['event_name'],
event['start_date'], event['end_date'],
int(event['max']), event['description'],
int(event['status']), event['players'])
result.append(levent)
return result
except (IOError, IndexError):
print('Failed to load event data.')
def generate_and_init(self, seed=None):
"""Generates the workload and initialises internal data structures.
"""
self.__reset()
random.seed(seed)
cur_time = 0
for i in range(self.num_processes):
cur_time += self._arrival_time()
new_process = Process(process_id=i,
arrival_time=cur_time,
service_time=self._service_time())
self.processes.append(new_process)
new_event = Event(process_id=new_process.process_id,
event_time=cur_time,
event_type=EventTypes.PROC_ARRIVES)
insort(self.events_queue, new_event) # 插入后自动排序
def get_events(table_str, descriptions_str):
"""Split a table up into fields, and interpolate with descriptions."""
# Parse the descriptions.
descriptions = get_descriptions(descriptions_str)
# Split into lines
lines = map(str.strip, table_str.split('\n'))
# Remove horizontal dividers
lines = [line for line in lines if line.count('-') < 20]
# Join the lines back together again (apart from the first), split at '|'s,
# strip the whitespace, remove empty fields, and finally parse each event.
return [
Event(event_str, descriptions)
for event_str in map(str.strip, ''.join(lines[1:]).split('|'))
if len(event_str)
]
def cls():
parameter_store = Mock()
parameter_store.fetch_parameter.return_value = str(event.stub_config)
organizations = Mock()
organizations.describe_ou_name.return_value = 'some_ou_name'
organizations.build_account_path.return_value = 'some_ou_path'
organizations.get_organization_info.return_value = {
"organization_master_account_id": "12345678910",
"organization_id": "id-123"
}
return Event(event=event.stub_event,
parameter_store=parameter_store,
organizations=organizations,
account_id=111111111111)
def create_event():
posts = MyProfile(current_user.username)
form = EventForm()
if request.method == 'POST':
if form.validate_on_submit():
event = Event(form.name.data, form.place.data, current_user.id,
form.date.data, form.time.data,
form.explanation.data, None)
event.save_to_db()
flash(f'Your event is created with name {form.name.data}!',
'success')
return redirect(url_for('owned_events'))
return render_template("createevent.html",
title="Create",
form=form,
posts=posts)
