Obtains the list of events that are unique to this object.
 If all = true, then this list will also include events that
 were defined within a module that the object extended.
426234
def singleton_events(all = true)
      if all
        contributors  = self.singleton_class.included_modules
        contributors -= self.class.included_modules
        contributors.push self.singleton_class
        Unobservable.collect_instance_events_defined_by(contributors)
      else
        Unobservable.collect_instance_events_defined_by([self.singleton_class])
      end
    end
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)
844559
public EventList getBaseEventList() {
		if (baseList == null) {
			// Construct on demand
			Object[] data = getInitialData();
			if (logger.isDebugEnabled()) {
				logger.debug("Table data: got " + data.length + " entries");
			}
			// Construct the event list of all our data and layer on the sorting
			EventList rawList = GlazedLists.eventList(Arrays.asList(data));
			int initialSortColumn = getInitialSortColumn();
			if (initialSortColumn >= 0) {
				String sortProperty = getColumnPropertyNames()[initialSortColumn];
				baseList = new SortedList(rawList, new PropertyComparator(
						sortProperty, false, true));
			} else {
				baseList = new SortedList(rawList);
			}
		}
		return baseList;
	}
276973
def support_event_list_simple(fn):
    
    @wraps(fn)
    def _wrapped(self, event, *args, **kwargs):
        if _is_event_list(event):
            result = []
            for e in event:
                ret = fn(self, e, *args, **kwargs)

                if ret is None:
                    continue

                if isinstance(ret, (tuple, list)):
                    result.extend(ret)
                else:
                    result.append(ret)

            if result:
                if len(result) == 1:
                    return result[0]
                return result
            return None
        else:
            return fn(self, event, *args, **kwargs)

    return _wrapped
943880
def get_allEvents(self):
        '''
        
        '''

        if not hasattr(self,'allEvents'):
            timeFilters = {'endTime__gte': timezone.now()}
            if getConstant('registration__displayLimitDays') or 0 > 0:
                timeFilters['startTime__lte'] = timezone.now() + timedelta(days=getConstant('registration__displayLimitDays'))

            # Get the Event listing here to avoid duplicate queries
            self.allEvents = Event.objects.filter(
                **timeFilters
            ).filter(
                Q(instance_of=PublicEvent) |
                Q(instance_of=Series)
            ).annotate(
                **self.get_annotations()
            ).exclude(
                Q(status=Event.RegStatus.hidden) |
                Q(status=Event.RegStatus.regHidden) |
                Q(status=Event.RegStatus.linkOnly)
            ).order_by(*self.get_ordering())

        return self.allEvents
699703
def GetEvents(self):
    
    for event in self._GetAttributeContainers('event'):
      if hasattr(event, 'event_data_row_identifier'):
        event_data_identifier = identifiers.SQLTableIdentifier(
            'event_data', event.event_data_row_identifier)
        event.SetEventDataIdentifier(event_data_identifier)

        del event.event_data_row_identifier

      yield event
1271190
def find_all_events(self, session=None):
        
        with self._session(session) as session:
            return session.query(TaskEvent).all()
837464
public List<EventDefinitionType<PortletAppType<T>>> getAllEventDefinition()
   {
      List<EventDefinitionType<PortletAppType<T>>> list = new ArrayList<EventDefinitionType<PortletAppType<T>>>();
      List<Node> nodeList = childNode.get("event-definition");
      for(Node node: nodeList)
      {
         EventDefinitionType<PortletAppType<T>>  type = new EventDefinitionTypeImpl<PortletAppType<T>>(this, "event-definition", childNode, node);
         list.add(type);
      }
      return list;
   }
253858
def get_events(object_key: str) -> List[Event]:
    """"""
    events_data = _get_events_data(object_key)
    return [Event.from_config(event_dict) for event_dict in events_data]
207115
def events
      return @events if @events
      @events = []
      path = "events/available/#{language_code}"
      result = call(path, http_method: :get)
      for event in result
        @events << ShakeTheCounter::Event.new(event, client: self)
      end
      return @events
    end
699091
def events(self):
        
        all_events = [{ensure_unicode(key): value for key, value in iteritems(ev)} for ev in self._events]

        for ev in all_events:
            to_decode = []
            for key, value in iteritems(ev):
                if isinstance(value, binary_type) and key != 'host':
                    to_decode.append(key)
            for key in to_decode:
                ev[key] = ensure_unicode(ev[key])

            if ev.get('tags'):
                ev['tags'] = normalize_tags(ev['tags'])

        return all_events
1054201
List<EventInfo> getEvents() {
        synchronized (events) {
            List<EventInfo> result = new ArrayList<>(events.size());
            for (ListIterator<EventInfo> iterator = events.listIterator(events.size()); iterator.hasPrevious();) {
                result.add(iterator.previous());
            }
            return result;
        }
    }
1304615
function(objEvents, name, callback, args) {
    if (objEvents) {
      var events = objEvents[name];
      var allEvents = objEvents.all;
      if (events && allEvents) allEvents = allEvents.slice();
      if (events) triggerEvents(events, args);
      if (allEvents) triggerEvents(allEvents, [name].concat(args));
    }
    return objEvents;
  }
466918
public List<EventDefinitionType<PortletDescriptor>> getAllEventDefinition()
   {
      List<EventDefinitionType<PortletDescriptor>> list = new ArrayList<EventDefinitionType<PortletDescriptor>>();
      List<Node> nodeList = model.get("event-definition");
      for(Node node: nodeList)
      {
         EventDefinitionType<PortletDescriptor>  type = new EventDefinitionTypeImpl<PortletDescriptor>(this, "event-definition", model, node);
         list.add(type);
      }
      return list;
   }
884636
public boolean hasEvents(final EventType _eventtype)
    {
        if (!this.eventChecked) {
            this.eventChecked = true;
            try {
                EventDefinition.addEvents(this);
            } catch (final EFapsException e) {
                AbstractAdminObject.LOG.error("Could not read events for Name:; {}', UUID: {}",  this.name, this.uuid);
            }
        }
        return this.events.get(_eventtype) != null;
    }
693804
def get_events(self, stack_name, chronological=True):
        """"""
        next_token = None
        event_list = []
        while True:
            if next_token is not None:
                events = self.cloudformation.describe_stack_events(
                    StackName=stack_name, NextToken=next_token
                )
            else:
                events = self.cloudformation.describe_stack_events(
                    StackName=stack_name
                )
            event_list.append(events['StackEvents'])
            next_token = events.get('NextToken', None)
            if next_token is None:
                break
            time.sleep(GET_EVENTS_SLEEP)
        if chronological:
            return reversed(sum(event_list, []))
        else:
            return sum(event_list, [])
574831
def get_events(self) -> List[Event]:
        
        LOG.debug('Getting events for %s', self.key)
        return get_events(self.key)