Gets all the experiment_summ_ids that map to a given coinc_event_id.
12618
def get_experiment_summ_ids( self, coinc_event_id ):
		
		experiment_summ_ids = []
		for row in self:
			if row.coinc_event_id == coinc_event_id:
				experiment_summ_ids.append(row.experiment_summ_id)
		if len(experiment_summ_ids) == 0:
			raise ValueError("'%s' could not be found in the experiment_map table" % coinc_event_id)
		return experiment_summ_ids
1199987
private Events _getEvents(PhaseId phaseId)
    {
        // Gather the events and purge the event list to prevent concurrent modification during broadcasting
        int size = _events.size();
        List<FacesEvent> anyPhase = new ArrayList<FacesEvent>(size);
        List<FacesEvent> onPhase = new ArrayList<FacesEvent>(size);
        
        for (int i = 0; i < size; i++)
        {
            FacesEvent event = _events.get(i);
            if (event.getPhaseId().equals(PhaseId.ANY_PHASE))
            {
                anyPhase.add(event);
                _events.remove(i);
                size--;
                i--;
            }
            else if (event.getPhaseId().equals(phaseId))
            {
                onPhase.add(event);
                _events.remove(i);
                size--;
                i--;
            }
        }
        
        return new Events(anyPhase, onPhase);
    }
193573
def get_all_formulae(chebi_ids):
    ''''''
    all_formulae = [get_formulae(chebi_id) for chebi_id in chebi_ids]
    return [x for sublist in all_formulae for x in sublist]
1274470
def get_run_events(cls, crawler, run_id, start, end, level=None):
        """"""
        key = make_key(crawler, "events", run_id, level)
        return cls.event_list(key, start, end)
567750
def get_ids(self, request_data, parameter_name='ids'):
        """"""
        if parameter_name not in request_data:
            raise ParseError("`{}` parameter is required".format(parameter_name))

        ids = request_data.get(parameter_name)
        if not isinstance(ids, list):
            raise ParseError("`{}` parameter not a list".format(parameter_name))

        if not ids:
            raise ParseError("`{}` parameter is empty".format(parameter_name))

        if any(map(lambda id: not isinstance(id, int), ids)):
            raise ParseError("`{}` parameter contains non-integers".format(parameter_name))

        return ids
1252828
private Set<String> getRelatedElementIds(String id) {

        Set<String> result = new HashSet<String>();
        if (id != null) {
            result.add(id);
            String serverId = getServerId(id);

            Iterator<String> it = m_elements.keySet().iterator();
            while (it.hasNext()) {
                String elId = it.next();
                if (elId.startsWith(serverId)) {
                    result.add(elId);
                }
            }

            Iterator<org.opencms.ade.containerpage.client.ui.CmsContainerPageElementPanel> itEl = getAllDragElements().iterator();
            while (itEl.hasNext()) {
                org.opencms.ade.containerpage.client.ui.CmsContainerPageElementPanel element = itEl.next();
                if (element.getId().startsWith(serverId)) {
                    result.add(element.getId());
                }
            }
        }
        return result;
    }
591746
def get_model_ids_to_fetch(events, context_hints_per_source):
    
    number_types = (complex, float) + six.integer_types
    model_ids_to_fetch = defaultdict(set)

    for event in events:
        context_hints = context_hints_per_source.get(event.source, {})
        for context_key, hints in context_hints.items():
            for d, value in dict_find(event.context, context_key):
                values = value if isinstance(value, list) else [value]
                model_ids_to_fetch[get_model(hints['app_name'], hints['model_name'])].update(
                    v for v in values if isinstance(v, number_types)
                )

    return model_ids_to_fetch
1338859
public synchronized EventData[] getEvents() {
        EventData[] ev_data = new EventData[events.size()];
        for (int i = 0; i < events.size(); i++)
            ev_data[i] = events.get(i);
        events.clear();
        return ev_data;
    }
431369
public List<Sample> getSamples(String studyId) {
        VariantStudyMetadata variantStudyMetadata = getVariantStudyMetadata(studyId);
        if (variantStudyMetadata == null) {
            logger.error("Study not found. Check your study ID: '{}'", studyId);
            return null;
        }

        List<Sample> samples = new ArrayList<>();
        if (variantStudyMetadata.getIndividuals() != null) {
            for (org.opencb.biodata.models.metadata.Individual individual : variantStudyMetadata.getIndividuals()) {
                for (Sample sample : individual.getSamples()) {
                    if (sample.getAnnotations() == null) {
                        sample.setAnnotations(new HashMap<>());
                    }
                    samples.add(sample);
                }
            }
        }
        return samples;
    }
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,
    )
1369615
def get_experiments(redis, active=True):
    """"""

    key = ACTIVE_EXPERIMENTS_REDIS_KEY if active else ARCHIVED_EXPERIMENTS_REDIS_KEY
    return [Experiment(redis, escape.to_unicode(name)) for name in redis.smembers(key)]
1157925
def all_group_experiments(self):
        
        from db.models.experiments import Experiment

        if self.is_selection:
            return Experiment.all.filter(selections=self)
        return Experiment.all.filter(experiment_group=self)
915844
def get_event_source_mapping_ids(EventSourceArn, FunctionName,
                                 region=None, key=None, keyid=None, profile=None):
    '''
    

    '''

    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
    try:
        mappings = []
        for maps in __utils__['boto3.paged_call'](conn.list_event_source_mappings,
                                                   EventSourceArn=EventSourceArn,
                                                   FunctionName=FunctionName):
            mappings.extend([mapping['UUID']
                             for mapping in maps['EventSourceMappings']])
        return mappings
    except ClientError as e:
        return {'error': __utils__['boto3.get_error'](e)}
858490
def events(self):
        
        events = [self.acknowledge_event] + self.verification_events
        return [x for x in events if x]
1343585
def getVerifiersIDs(self):
        
        verifiers_ids = list()
        for brain in self.getAnalyses():
            verifiers_ids += brain.getVerificators
        return list(set(verifiers_ids))
420965
def all_domain_events(self):
        
        for originator_id in self.record_manager.all_sequence_ids():
            for domain_event in self.get_domain_events(originator_id=originator_id, page_size=100):
                yield domain_event
537497
def map_exp_ids(self, exp):
        
        names = self.exp_feature_names
        if self.discretized_feature_names is not None:
            names = self.discretized_feature_names
        return [(names[x[0]], x[1]) for x in exp]