def add_event_to_channel(self, orig, channel_idx): if orig in self.origs[channel_idx]: return self.orig2e[channel_idx][orig] event_idx = self.sizes[channel_idx] e = events.Event(event_idx, orig) self.i2e[channel_idx][event_idx] = e self.orig2e[channel_idx][orig] = e self.events[channel_idx].add(e) self.origs[channel_idx].add(orig) return e
def Update(self, timeElapsed): if self.moveOrder is not None: direction = np.array(self.moveOrder) - np.array(self.pos) dirMag = np.linalg.norm(direction, ord=2) if dirMag > 0.: direction /= dirMag if dirMag < timeElapsed * self.speed: self.pos = self.moveOrder self.moveOrder = None else: self.pos += direction * timeElapsed * self.speed if self.attackOrder is not None: event = events.Event("getpos") event.objId = self.attackOrder getEnemyPosRet = self.mediator.Send(event) getEnemyPos = getEnemyPosRet[0] direction = getEnemyPos - np.array(self.pos) dirMag = np.linalg.norm(direction, ord=2) if dirMag > 0.: direction /= dirMag if dirMag > self.attackRange * 0.95: self.pos += direction * timeElapsed * self.speed if dirMag <= self.attackRange: #Check if we can fire durationSinceFiring = None timeNow = (pygame.time.get_ticks() / 1000.) if self.fireTime is not None: durationSinceFiring = timeNow - self.fireTime if durationSinceFiring is None or self.firePeriod < durationSinceFiring: self.fireTime = timeNow fireEvent = events.Event("fireshell") fireEvent.targetPos = getEnemyPos.copy() fireEvent.targetId = self.attackOrder fireEvent.firerId = self.objId fireEvent.playerId = self.playerId fireEvent.firerPos = self.pos.copy() fireEvent.speed = 100. self.mediator.Send(fireEvent)
def triggerEvent(self, eventType, **params): #{{{ utils.logger.debug("Model " + str(self) + " triggered eventType: "+str(eventType)+ " params: "+str(params)) subscriptionsCopy = copy.copy(self.__subscriptions) for typ, method, subscriptionID, sessionID in subscriptionsCopy: if typ == eventType: event = events.Event(self, eventType, params) try: method(event) except: utils.logger.exception('Exception while event triggering')
def on_privmsg(event): if BOT is None: return if BOT.in_batch: return prefix = BOT.prefix if event.target.startswith("#") else "" if event.message.startswith(prefix): parts = event.message.split(" ") parts[0] = parts[0][len(prefix):] event_out = events.Event("command_" + parts.pop(0), parts=parts) event_out.data.update(event.data) BOT.event_manager(event_out)
def onEvent(self, event): self.log.append(event) if event.type == events.MOTION_EVENT: brightness_control = events.Event(events.BRIGHTNESS_CONTROL_EVENT, event.fire_time + CLOUD_DELAY, "cloud", "cloud") brightness_control.params = { "light_brightness": 0.7, "light_id": event.source } self._writeCount = self._writeCount + 1 return [brightness_control] if event.type == events.BRIGHTNESS_CONTROL_EVENT: brightness_control = events.Event(events.BRIGHTNESS_CONTROL_EVENT, event.fire_time + CLOUD_DELAY, "cloud", event.params["light_id"]) brightness_control.params = { "light_brightness": event.params["light_brightness"], "light_id": event.params["light_id"] } new_network_send = events.Event(events.NETWORK_SEND, event.fire_time + CLOUD_DELAY, "cloud", self.node) new_network_send.params = { "src": "cloud", "dest": event.params["light_id"], "payload": brightness_control, "proto": events.UDP_SEND } self._readCount = self._readCount + 1 return [new_network_send] if event.type == events.UPDATE_DEFAULT_BRIGHTNESS_EVENT: return [] if event.type == events.EXIT_EVENT: self._time = event.fire_time return []
def __ProcessLogoutResp(self, logout_resp): try: cmd = self.__cmds[logout_resp.InitiatorTaskTag] cmd.resp_pdu = logout_resp if logout_resp.Response == pdu.LogoutRespPDU.RESPONSE_SUCC: #self.ProcessEvent(event) self.__init_event_listener.Signal( events.Event(events.Event.ID_LOGGED_OUT)) except KeyError: self.logger.error("login response for wrong initiator task id") return
def test_add_and_then_query(self): T = 12345 n = 1234 timeline = events.Timeline() slow_timeline = [] ID = 0 for _ in range(n): t = random.random() * T timeline.add_event(events.Event(t, ID)) slow_timeline.append(events.Event(t, ID)) ID += 1 for _ in range(n): bounds = sorted([random.random() * T, random.random() * T]) one = timeline.events_in_range(*bounds) two = [ e for e in slow_timeline if bounds[0] <= e.time <= bounds[1] ] self.assertEqual(sorted_time_description(one), sorted_time_description(two), "Test 1 failed.")
def list_onboarded_users(self, owner_id, offset=0, limit=20): new_user_event = events.Event("Users Create User", self.db, self.logger) user_count = new_user_event.get_event_count(owner_id) all_users = new_user_event.get_latest_events(user_count) sliced_users = all_users[offset:limit] output = [] for each in sliced_users: json_data = json.loads(each[0]) if "new_user_id" in json_data: output.append(self.get_user_info(json_data["new_user_id"])) return output
def add_event_to_all(self, orig): ''' Adds an event (the original event, not an index) to all channels ''' if orig in self.origs[0]: # TODO return self.orig2e[0][orig] for channel_idx in range(self.num_channels): event_idx = self.sizes[channel_idx] e = events.Event(event_idx, orig) self.i2e[channel_idx][event_idx] = e self.orig2e[channel_idx][orig] = e self.events[channel_idx].add(e) self.origs[channel_idx].add(orig) return e
def changeTurn(self): self.turn += 1 if self.turn == len(global_vars.idLookup): self.turn = 0 try: while not self.eventManager.isMember( global_vars.idLookup[self.turn]): self.turn += 1 except: self.changeTurn() e = events.Event(type='turn', t=self.turn) self.eventManager.post(e) return self.turn
def _tcpReceive(self, event): tcp_type = event.params["tcp-type"] if tcp_type == "ACK": return [] event.fire_time += TCP_RECEIVE_DELAY if self._hosts[event.params["dest"]] == self.id: if tcp_type == "SYN" or tcp_type == "SYN-ACK": response = events.Event( events.TCP_SEND, event.fire_time, self.id, event.params["src"], params={ "tcp-type": "SYN-ACK" if tcp_type == "SYN" else "ACK", "seq-no": event.params["seq-no"], "src": event.params["dest"], "dest": event.params["src"] }) if tcp_type == "SYN": return [response] elif tcp_type == "SYN-ACK": message = self._pending_messages[event.params["seq-no"]] message.fire_time = event.fire_time + TCP_ACK_DELAY return [response, message] elif tcp_type == "MSG": return [ events.Event(events.NETWORK_RECEIVE, event.fire_time, self.id, self.id, params=event.params) ] else: return self._tcpSend(event)
def play(): ''' Main game loop Accepts user input and posts relevant events, handles pause state, ticks engine, etc. ''' global oldTime global turn paused = False while True: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() return elif event.type == KEYDOWN: if event.key == K_ESCAPE: pygame.event.post(pygame.event.Event(QUIT)) if event.key == K_p: paused ^= True if event.key == K_r: global_vars.eventManager.post(events.Event(type='draw terrain')) if event.key == K_t: global_vars.eventManager.post(events.Event(type='render tanks')) if event.key == K_RIGHT or event.key == K_d: global_vars.eventManager.post(events.Event(type='right down')) if event.key == K_LEFT or event.key == K_a: global_vars.eventManager.post(events.Event(type='left down')) elif event.type == KEYUP: if event.key == K_RIGHT or event.key == K_d: global_vars.eventManager.post(events.Event(type='right up')) if event.key == K_LEFT or event.key == K_a: global_vars.eventManager.post(events.Event(type='left up')) elif event.type == MOUSEMOTION: mousex, mousey = event.pos elif event.type == MOUSEBUTTONUP: mousex, mousey = event.pos e = events.Event(type = 'click', x = mousex, y = mousey) eventManager.post(e) turn = ctr.changeTurn() oldTime = time.time() if time.time() - oldTime > _fps: pygame.display.update() oldTime = time.time() else: while time.time() - oldTime < _fps: pass if not paused: tick()
def _udpReceive(self, event): event.fire_time += UDP_RECEIVE_DELAY if self._hosts[event.params["dest"]] == self.id: return [ events.Event(events.NETWORK_RECEIVE, event.fire_time, self.id, self.id, params=event.params) ] else: return self._udpSend(event)
def test_get_uri(self): '''Simple coverage test to check the get_uri method works under the following scenarios: - No page field set and no module (ModuleURI) field set. - page field set but no module (ModuleURI) field set. - No page field set but module (ModuleURI) field set. - page field set and module (ModuleURI) field set. ''' event = events.Event({}) self.assertEqual('https://unknown/', event.get_uri()) event.set_data_attr('page', 'https://edx.org/') self.assertEqual('https://edx.org/', event.get_uri()) event = events.Event({}) event.set_data_attr( 'module', ModuleURI( '/courses/MITx/1.111x/2010_Spring/modx/i4x://MITx/1.111x/problem/a/problem_get' )) self.assertEqual('https://unknown/problem/a/', event.get_uri()) event.set_data_attr('page', 'https://edx.org/') self.assertEqual('https://edx.org/problem/a/', event.get_uri())
def convert_json_to_event(event_json): data = event_json['log_data'] timestamp = datetime.fromtimestamp(data['timestampMillis'] / 1000) if event_json['log_type'] == 'event': return events.Event(event_type=events.EventType.PSEUDO, timestamp=timestamp) elif event_json['log_type'] == 'foreground_app': return events.AppActivityUsageEvent( timestamp=timestamp, app_id=data['packageName'], source_class=data['sourceClassName']) elif event_json['log_type'] == 'system_snapshot': return events.SystemMemorySnapshot(timestamp=timestamp)
def test_set_data_attr(self): '''Simple coverage test to check the field setter method works correctly. The setter function should ignore any false types. ''' event = events.Event({}) event.set_data_attr('key', 'value') self.assertEqual('value', event['key']) event.set_data_attr('key', False) self.assertEqual('value', event['key']) event.set_data_attr('key', '') self.assertEqual('value', event['key']) event.set_data_attr('key', None) self.assertEqual('value', event['key'])
def test_event_no_data(self): calls = [] def handler(data): calls.append(data) event = events.Event() event += handler event.notify() event() self.assertEqual(calls, [None, None])
def testUDP(a, b): """testUDP(a, b) -> Validates the path of a UDP message between a and b.""" msg_params = { "proto": UDP, # Additional param for NETWORK_SEND event. # Typical network event parameters: "src": "LIGHT-1", "dest": "LIGHT-2", "payload": events.Event(events.UPDATE_DEFAULT_BRIGHTNESS_EVENT, None, "LIGHT-1", "LIGHT-2", params={"new-brightness": .2}) } net_event = events.Event(events.NETWORK_SEND, 0, "LIGHT-1", "NET-1", msg_params) # Light 1 tells Net 1 to send info after_net_send = a.onEvent(net_event)[0] assert after_net_send.type == events.UDP_SEND # Net 1 tells Net 2 that its sending info after_udp_send = a.onEvent(after_net_send)[0] assert after_udp_send.type == events.UDP_RECEIVE # Net 2 gets the event after_udp_receive = b.onEvent(after_udp_send)[0] assert after_udp_receive.type == events.NETWORK_RECEIVE # Net 2 tells Light 2 that it should adjust brightness after_net_receive = b.onEvent(after_udp_receive)[0] assert after_net_receive.type == events.UPDATE_DEFAULT_BRIGHTNESS_EVENT
def WorldClick(self, worldPos, button): if button == 1: for objId in self.objs: obj = self.objs[objId] if obj.playerId != self.playerId: continue obj.MoveTo(worldPos) moveOrder = events.Event("moveorder") moveOrder.objId = obj.objId moveOrder.pos = worldPos self.mediator.Send(moveOrder) if button == 3: bestUuid, bestDist = self.ObjNearPos(worldPos, 1) clickTolerance = 5. if bestUuid is not None and bestDist < clickTolerance: for objId in self.objs: obj = self.objs[objId] if obj.playerId != self.playerId: continue obj.Attack(bestUuid) if bestUuid is not None: attackOrder = events.Event("attackorder") attackOrder.attackerId = obj.objId attackOrder.targetId = bestUuid self.mediator.Send(attackOrder) if bestUuid is None or bestDist >= clickTolerance: for objId in self.objs: obj = self.objs[objId] if obj.playerId != self.playerId: continue #Stop attack obj.Attack(None) stopOrder = events.Event("stoporder") stopOrder.objId = obj.objId self.mediator.Send(stopOrder)
def parse_cal(link): """Returns a list of all events in someone's calendar""" lst = [] with open(link, "rb") as c: all_text = c.read() cal = Calendar.from_ical(all_text) for component in cal.walk("vevent"): name = component.get('summary') start = component.decoded('dtstart') #aware datetime end = component.decoded('dtend') #aware datetime temp = events.Event(name, start, end) lst.append(temp) return lst
def homepage_create_user(): if request.method == "POST": if EMAIL_REGEX.match(request.form['email_address']) is None: error = "Invalid e-mail address." return render_template("create_user.jinja2", error_msg=error) if len(request.form['passwd']) < 8: error = "Passwords must consist of at least 8 characters." return render_template("create_user.jinja2", error_msg=error) if request.form["passwd"] == request.form["passwd_repeat"]: ip_addr = request.access_route[-1] user_passwd = request.form["passwd"] full_name = request.form["full_name"] db = Database() result = db.create_user(full_name, request.form['email_address'], user_passwd, ip_addr) if result: if result[0] == -1: error = "User with this e-mail address already exists." return render_template("create_user.jinja2", error_msg=error) session_id = result[1] # log event create_user_event = events.Event("Users Create User", db, logger=current_app.logger) metadata = {"ip_addr": ip_addr, "created_by": "self"} create_user_event.log_event(result[0], json.dumps(metadata)) user_ctx = users.UserContext(result[0], db=db, logger=current_app.logger) # default permissions user_ctx.add_permission("onboard-users") user_ctx.add_permission("launch-ico") user_ctx.add_permission("ethereum-network") db.update_user_permissions(result[0], user_ctx.acl()) config_stream = open("config.json", "r") config_data = json.load(config_stream) config_stream.close() if config_data["new_user_tokens"] > 0: cr = Credits(result[0], db, current_app.logger) cr.issue_credits(config_data["new_user_tokens"], {"ip_addr": ip_addr, "reason": "New User Bonus"}) return redirect(url_for("admin.admin_main", session_token=session_id)) else: error = "Passwords did not match." return render_template("create_user.jinja2", error_msg=error) return render_template("create_user.jinja2")
def _networkSend(self, event): proto = event.params["proto"] send_event = events.Event(proto, event.fire_time + TO_NET_DELAY, event.source, self.id, params={ "src": event.params["src"], "dest": event.params["dest"], "payload": event.params["payload"] }) return [send_event]
def dispatch_directed_command(api_key): db = database.Database(current_app.logger) ip_addr = request.access_route[-1] node_id = db.validate_api_key(api_key) if node_id: next_command = db.get_next_directed_command(node_id) if next_command: command_id = next_command[0] command_data = json.loads(next_command[1]) new_event = events.Event("Ethereum Node Command Dispatch", db, current_app.logger) event_data = { "ip_address": ip_addr, "node_id": node_id, "command": json.dumps(command_data), "command_id": command_id } new_event_id = new_event.log_event(node_id, json.dumps(event_data)) command_data["command_id"] = command_id command_data["event_id"] = new_event_id command_data["directed"] = True if db.dispatch_directed_command(command_id, new_event_id): return Response( json.dumps({ "result": "OK", "command_data": command_data })) else: return Response( json.dumps({ "result": "Error", "error_message": "Could not dispatch command {0}".format(command_id) })) else: return Response( json.dumps({ "result": "Error", "error_message": "Could not fetch next directed command" })) else: return Response( json.dumps({ "result": "Error", "error_message": "Invalid API key" }))
def test_do_no_stringify_nonetype(self): '''Ensure that when a field is not set, an event __getitem__ call returns None. In the translation project there is code resembling the following: if event['unset_field']: <conditional body> However, old implementations of the base Event class would stringify any __getitem__ calls which resulted in behavior where an unset field would return the string "None", which consequently led to conditional code like the aforementioned snippet always executing. ''' event = events.Event({}) self.assertEqual(None, event['unset_field'])
def ingest(event, database): ''' Insert/update event into the databse ''' # Check if the customer is new #customer_id = event.get('key') if event.get('customer_id'): customer_id = event.get('customer_id') else: customer_id = event.get('key') try: customer = database.customers.get(customer_id) except: customer = None # Insert new customer to database with customer_id if not customer: customer = events.Customer(event) database.insertCustomer(customer) # Add/update event in database if event['type'] == event_type['order']: order = events.Order(event) # Update existing order amount customer.updateOrderAmount(order, database.orders) database.insertOrder(order) elif event['type'] == event_type['image']: image = events.Image(event) database.insertImage(image) elif event['type'] == event_type['site_visit']: site_visit = events.SiteVisit(event) customer.increaseSiteVisit() # Update site visit count for existing customer database.insertSiteVisit(site_visit) elif event['type'] == event_type['customer']: # Update existing customer attributes customer.updateCustomerAttr(event) database.insertCustomer(customer) else: e = events.Event(event) database.insertEvent(e) # Update the latest customer interaction in database database.getMax(event) return database
def __init__(self, pos, size, state_images, do_resize=False): super(Button, self).__init__() # states: 0=normal, 1=hover, 2=pressed, 3=disabled self._images = state_images self.rect = pygame.Rect(pos, size) self.rect.center = pos self.state = self.NORMAL # resize images to fit button size if do_resize: for idx, img in enumerate(self._images): self._images[idx] = pygame.transform.smoothscale( img, self.rect.size) self.image = self._images[0] self.event_clicked = events.Event()
def test_get_resource_display_name(self): '''Simple coverage test to check the get_resource_name method works under the following scenarios: - No resource_display_name field set but module (ModuleURI) is set - resource_display_name field set and module (ModuleURI) is set ''' event = events.Event({}) event.set_data_attr( 'module', ModuleURI( '/courses/MITx/2.111x/2010_Spring/modx/i4x://MITx/2.111x/problem/a/problem_get' )) self.assertEqual('a', event.get_resource_display_name()) event.set_data_attr('resource_display_name', 'display_name') self.assertEqual('display_name', event.get_resource_display_name())
def update_fov(self): player = self.world.player pos = self.world.player.pos level = self.world.levels[player.dlevel] new_fov = set(fov.calculate_fov(pos, FOV_RADIUS, level)) for pos in player.tiles_in_sight.difference(new_fov): tile_info = world.TileInfo(pos, level[pos.x, pos.y]) events.events.handle_event( events.Event(events.EventType.TILE_HIDDEN, tile_info)) for pos in new_fov.difference(player.tiles_in_sight): world.reveal_tile(level, pos) player.tiles_in_sight = new_fov
def onEvent(self, *args): """ Will be called when receiving an event from the broadcaster. See onConnect which subscribes to the targets. """ try: # Wamp v1: onEvent is callbacked with topic and event target, event_data = args except ValueError: # Wamp v2: onEvent is callbacked with event event_data, = args target = None event = events.Event(target, event_data) if event.is_a_vote: voting_fsm = self.states.get(event.tracking_id) if not voting_fsm: log.msg('Ignoring vote %r because I have already lost' % event.vote) return own_vote = voting_fsm.vote is_a_fold = (own_vote < event.vote) if is_a_fold: log.msg( 'Folding due to vote %r being higher than own vote %r' % (event.vote, own_vote)) voting_fsm.fold() else: log.msg('Calling due to vote %r being lower than own vote %r' % (event.vote, own_vote)) voting_fsm.call() elif event.is_a_request: try: self.handle_request(event) except Exception as e: log.err(e.message) for line in traceback.format_exc().splitlines(): log.err(line) self.publish_failed(event, e.message) else: log.msg(str(event))
def test_clear_handlers(self): calls = set() def handler_one(data): calls.add("one") def handler_two(data): calls.add("two") event = events.Event() event += handler_one event += handler_two event.clear_handlers() self.assertEqual(calls, set())