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)