Helper to get all events of the Registry contract at `registry_address`.
509948
def get_token_network_registry_events(
        chain: BlockChainService,
        token_network_registry_address: PaymentNetworkID,
        contract_manager: ContractManager,
        events: Optional[List[str]] = ALL_EVENTS,
        from_block: BlockSpecification = GENESIS_BLOCK_NUMBER,
        to_block: BlockSpecification = 'latest',
) -> List[Dict]:
    
    return get_contract_events(
        chain=chain,
        abi=contract_manager.get_contract_abi(CONTRACT_TOKEN_NETWORK_REGISTRY),
        contract_address=Address(token_network_registry_address),
        topics=events,
        from_block=from_block,
        to_block=to_block,
    )
352999
def getaddresses(fieldvalues):
    """"""
    all = COMMASPACE.join(fieldvalues)
    a = _AddressList(all)
    return a.addresslist
1149230
def get_all_netting_channel_events(
        chain: BlockChainService,
        token_network_address: TokenNetworkAddress,
        netting_channel_identifier: ChannelID,
        contract_manager: ContractManager,
        from_block: BlockSpecification = GENESIS_BLOCK_NUMBER,
        to_block: BlockSpecification = 'latest',
) -> List[Dict]:
    

    filter_args = get_filter_args_for_all_events_from_channel(
        token_network_address=token_network_address,
        channel_identifier=netting_channel_identifier,
        contract_manager=contract_manager,
        from_block=from_block,
        to_block=to_block,
    )

    return get_contract_events(
        chain,
        contract_manager.get_contract_abi(CONTRACT_TOKEN_NETWORK),
        typing.Address(token_network_address),
        filter_args['topics'],
        from_block,
        to_block,
    )
763419
def _getPastEvents(self, request):
        """"""
        home = request.site.root_page
        return getAllPastEvents(request, home=home)
336531
def get_context_data(self,**kwargs):
        '''  '''
        context = self.get_listing()
        context['showDescriptionRule'] = getConstant('registration__showDescriptionRule') or 'all'
        context.update(kwargs)

        # Update the site session data so that registration processes know to send return links to
        # the registration page.  set_return_page() is in SiteHistoryMixin.
        self.set_return_page('registration',_('Registration'))

        return super(ClassRegistrationView,self).get_context_data(**context)
481811
def subsite_upcoming_events(context):
    
    request = context['request']
    home = request.site.root_page
    return {'request': request,
            'events':  getAllUpcomingEvents(request, home=home)}
1266858
def _get_domain_event_detail(event, detail):
    '''
    
    '''
    event_name = _get_libvirt_enum_string('VIR_DOMAIN_EVENT_', event)
    if event_name == 'unknown':
        return event_name, 'unknown'

    prefix = 'VIR_DOMAIN_EVENT_{0}_'.format(event_name.upper())
    detail_name = _get_libvirt_enum_string(prefix, detail)

    return event_name, detail_name
382898
def get_address_transactions(self, address_id, **params):
        """"""
        return self.api_client.get_address_transactions(self.id, address_id, **params)
1317589
def get_all_events(self):
        
        self.all_events = {}
        events = self.tree.findall('EVENT')
        events += self.tree.findall('CC')
        for e in events:
            event_id = e.attrib['id']
            if event_id in self._static_events:
                continue
            event_type = e.find('type').text
            try:
                self.all_events[event_type].append(event_id)
            except KeyError:
                self.all_events[event_type] = [event_id]
1104747
def get_events(self):
        
        return github.PaginatedList.PaginatedList(
            github.Event.Event,
            self._requester,
            self.url + "/events",
            None
        )
1294530
def get_contract_events(
        chain: BlockChainService,
        abi: Dict,
        contract_address: Address,
        topics: Optional[List[str]],
        from_block: BlockSpecification,
        to_block: BlockSpecification,
) -> List[Dict]:
    
    verify_block_number(from_block, 'from_block')
    verify_block_number(to_block, 'to_block')
    events = chain.client.get_filter_events(
        contract_address,
        topics=topics,
        from_block=from_block,
        to_block=to_block,
    )

    result = []
    for event in events:
        decoded_event = dict(decode_event(abi, event))
        if event.get('blockNumber'):
            decoded_event['block_number'] = event['blockNumber']
            del decoded_event['blockNumber']
        result.append(decoded_event)
    return result
939321
def _get_events(self):
        """"""
        events, changed_container_ids = self.docker_util.get_events()
        if not self._disable_net_metrics:
            self._invalidate_network_mapping_cache(events)
        if changed_container_ids and self._service_discovery:
            get_sd_backend(self.agentConfig).update_checks(changed_container_ids)
        if changed_container_ids:
            self.metadata_collector.invalidate_cache(events)
        return events
1188340
def get_domain_events(self, originator_id, gt=None, gte=None, lt=None, lte=None, limit=None, is_ascending=True,
                          page_size=None):
        
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"))
1152127
def load_all_details(self):
    
    log.debug(u"Loading all details")
    if self.count > 0:
      # Now, empty out the events to prevent duplicates!
      del(self.events[:])

      # Send the SOAP request with the list of exchange ID values.
      log.debug(u"Requesting all event details for events: {event_list}".format(event_list=str(self.event_ids)))
      body = soap_request.get_item(exchange_id=self.event_ids, format=u'AllProperties')
      response_xml = self.service.send(body)

      # Re-parse the results for all the details!
      self._parse_response_for_all_events(response_xml)

    return self
304350
def attach_events(self, *events, **kwargs):
        """"""
        reg = self.registry
        insert = 'insert' in kwargs
        for e in events:
            cregexp = e.compile(self.config)
            regexp = getattr(e.regexp, 're', e.regexp)
            if regexp not in reg.events[e.iotype]:
                if insert:
                    reg.events_re[e.iotype].insert(0, (regexp, cregexp))
                else:
                    reg.events_re[e.iotype].append((regexp, cregexp))
            if insert:
                reg.events[e.iotype][regexp].insert(0, e)
            else:
                reg.events[e.iotype][regexp].append(e)
1297769
def get_network_events(self):
        
        return github.PaginatedList.PaginatedList(
            github.Event.Event,
            self._requester,
            "/networks/" + self.owner.login + "/" + self.name + "/events",
            None
        )