events from a particular stage
188345
def get_stage_events(cls, crawler, stage_name, start, end, level=None):
        """"""
        key = make_key(crawler, "events", stage_name, level)
        return cls.event_list(key, start, end)
574989
synchronized void nextEvent() {
        if (currentPosition > positionOfLastSync) {
            throw new IllegalStateException("Cannot advance past the last" +
                                                    " EV_SYN EV_SYN_REPORT 0");
        }
        currentPosition += eventStruct.getSize();
        if (MonocleSettings.settings.traceEventsVerbose && hasNextEvent()) {
            MonocleTrace.traceEvent("Processing %s [index=%d]",
                                    getEventDescription(), currentPosition);
        }
    }
976282
def _runable_for_event(f, tag, stage):
    

    if not hasattr(f, '__ambry_event__'):
        return False

    f_tag, f_stage = f.__ambry_event__

    if stage is None:
        stage = 0

    if tag != f_tag or stage != f_stage:
        return False

    return True
1000405
public void addEvent(UserFeedbackEvent.Level level, UserFeedbackEvent.Stage stage, String message) {
    addEvent(new UserFeedbackEvent(autoML, level, stage, message));
  }
1350840
def getEvents(self):
        

        url = "https://redunda.sobotics.org/events.json"
        data = parse.urlencode({"key": self.key}).encode()

        req = request.Request(url, data)
        
        response = request.urlopen(req)

        return json.loads(response.read().decode("utf-8"))
874633
def get_events(conn, stackname):
    """"""
    next = None
    event_list = []
    while 1:
        events = conn.describe_stack_events(stackname, next)
        event_list.append(events)
        if events.next_token is None:
            break
        next = events.next_token
        time.sleep(1)
    return reversed(sum(event_list, []))
450510
def getEvents(self, repo_user, repo_name, until_id=None):
        """"""
        done = False
        page = 0
        events = []
        while not done:
            new_events = yield self.api.makeRequest(
                    ['repos', repo_user, repo_name, 'events'],
                    page)

            # terminate if we find a matching ID
            if new_events:
                for event in new_events:
                    if event['id'] == until_id:
                        done = True
                        break
                    events.append(event)
            else:
                done = True

            page += 1
        defer.returnValue(events)
1139639
def trigger_events(events, loop):
    
    for event in events:
        result = event(loop)
        if isawaitable(result):
            loop.run_until_complete(result)
1235551
def stage():
    """"""
    common_conf()
    env.user = settings.LOGIN_USER_STAGE
    env.machine = 'stage'
    env.host_string = settings.HOST_STAGE
    env.hosts = [env.host_string, ]
722461
def process_events(events)
      process_join events['join'] if events.key? 'join'
      process_invite events['invite'] if events.key? 'invite'
      process_leave events['leave'] if events.key? 'leave'
    end
742615
def get_stages(self):
        '''
        
        '''
        sequence = self.get_sequence()
        return {
            'current': [e.dst.get_name() for e in sequence],
            'stages': {e.src.get_name(): [e.dst.get_name()] for e in sequence}
        }
891872
def events(self):
        
        if not self.event_reflector:
            return []

        events = []
        for event in self.event_reflector.events:
            if event.involved_object.name != self.pod_name:
                # only consider events for my pod name
                continue

            if self._last_event and event.metadata.uid == self._last_event:
                # saw last_event marker, ignore any previous events
                # and only consider future events
                # only include events *after* our _last_event marker
                events = []
            else:
                events.append(event)
        return events
306363
def __handle_events(self):
        """"""
        events = pygame.event.get()
        for event in events:
            if event.type == pygame.QUIT:
                self.exit()
1267919
def get_events(self):
        '''
        
        '''
        ret = []
        while True:
            event = self.event.get_event(wait=1, full=True)
            if event is None:
                return ret
            ret.append(event)
1330004
private void collectStartVertices(final ExecutionStage stage) {

		for (int i = 0; i < stage.getNumberOfStageMembers(); i++) {

			final ExecutionGroupVertex groupVertex = stage.getStageMember(i);

			if (forward) {
				if ((groupVertex.getNumberOfBackwardLinks() == 0)
					|| ((this.stage >= 0) && allConnectionsFromOtherStage(groupVertex, true))) {
					this.entryVertices.add(groupVertex);
				}
			} else {
				if ((groupVertex.getNumberOfForwardLinks() == 0)
					|| ((this.stage >= 0) && allConnectionsFromOtherStage(groupVertex, false))) {
					this.entryVertices.add(groupVertex);
				}
			}
		}
	}
8677
def _run_events(self, tag, stage=None):
        """"""

        self._run_event_methods(tag, stage)
        self._run_tests(tag, stage)
575655
def _get_events(self, result):
        """""""
        events = []

        for event_data in result:
            event = Event.factory(event_data)

            if event is not None:
                events.append(event)

                if isinstance(event, DeviceStateChangedEvent):
                    # change device state
                    if self.__devices[event.device_url] is None:
                        raise Exception(
                            "Received device change " +
                            "state for unknown device '" +
                            event.device_url + "'")

                    self.__devices[event.device_url].set_active_states(
                        event.states)

        return events