Returns IDs of all attacks (targeted and non-targeted).
15527
def get_all_attack_ids(self):
    """"""
    return list(self.attacks.keys()) + list(self.targeted_attacks.keys())
204990
public String[] getIdentifiers()
	{
		final PerSessionInfo[] infos;
		synchronized (sessions)
		{
			infos = (PerSessionInfo[]) sessions.values().toArray(new PerSessionInfo[sessions.size()]);
		}
		int count = 0;
		for (int i = 0; i < infos.length; ++i)
		{
			if (infos[i] != null && infos[i].identifier != null)
			{
				++count;
			}
		}
		if (count > 0)
		{
			final String[] result = new String[count];
			int index = 0;
			for (int i = 0; i < infos.length; ++i)
			{
				if (infos[i] != null && infos[i].identifier != null)
				{
					result[index++] = infos[i].identifier;
				}
			}
			return result;
		} else
		{
			return null;
		}
	}
218006
public java.util.List<String> getAddSecurityGroupIds() {
        if (addSecurityGroupIds == null) {
            addSecurityGroupIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return addSecurityGroupIds;
    }
1223307
def list_security_groups(self, retrieve_all=True, **_params):
        """"""
        return self.list('security_groups', self.security_groups_path,
                         retrieve_all, **_params)
1104265
public function getAllNodeIdentifiers()
    {
        $ret = [];

        if ($this->isSuccessful) {
            foreach ($this->rawResponse['hits']['hits'] as $document) {
                $ret[] = $document['_id'];
            }
        }

        return $ret;
    }
240279
def all(cls, otp=False, ccid=False, u2f=False):
        """"""
        pids = set([
            cls.YUBIKEY,
            cls.NEO_OTP,
            cls.NEO_OTP_CCID,
            cls.NEO_CCID,
            cls.NEO_U2F,
            cls.NEO_OTP_U2F,
            cls.NEO_U2F_CCID,
            cls.NEO_OTP_U2F_CCID,
            cls.NEO_SKY,
            cls.YK4_OTP,
            cls.YK4_U2F,
            cls.YK4_OTP_U2F,
            cls.YK4_CCID,
            cls.YK4_OTP_CCID,
            cls.YK4_U2F_CCID,
            cls.YK4_OTP_U2F_CCID,
            cls.PLUS_U2F_OTP
        ])

        if otp:
            pids.difference_update(set([
                cls.NEO_CCID,
                cls.NEO_U2F,
                cls.NEO_U2F_CCID,
                cls.NEO_SKY,
                cls.YK4_U2F,
                cls.YK4_CCID,
                cls.YK4_U2F_CCID
            ]))

        if ccid:
            pids.difference_update(set([
                cls.YUBIKEY,
                cls.NEO_OTP,
                cls.NEO_U2F,
                cls.NEO_OTP_U2F,
                cls.NEO_SKY,
                cls.YK4_OTP,
                cls.YK4_U2F,
                cls.YK4_OTP_U2F,
                cls.PLUS_U2F_OTP
            ]))

        if u2f:
            pids.difference_update(set([
                cls.YUBIKEY,
                cls.NEO_OTP,
                cls.NEO_OTP_CCID,
                cls.NEO_CCID,
                cls.YK4_OTP,
                cls.YK4_CCID,
                cls.YK4_OTP_CCID
            ]))

        return pids
1358927
def scan(self, ids=range(254)):
        
        return [id for id in ids if self.ping(id)]
988961
def getAnalysesUIDs(self):
        
        analyses = self.getAnalyses()
        if isinstance(analyses, list):
            return [an.UID() for an in analyses]
        return []
791908
def getStrikes(self, contract_identifier, smin=None, smax=None):
        
        strikes = []
        contracts = self.contractDetails(contract_identifier)["contracts"]

        if contracts[0].m_secType not in ("FOP", "OPT"):
            return []

        # collect expirations
        for contract in contracts:
            strikes.append(contract.m_strike)

        # convert to floats
        strikes = list(map(float, strikes))
        # strikes = list(set(strikes))

        # get min/max
        if smin is not None or smax is not None:
            smin = smin if smin is not None else 0
            smax = smax if smax is not None else 1000000000
            srange = list(set(range(smin, smax, 1)))
            strikes = [n for n in strikes if n in srange]

        strikes.sort()
        return tuple(strikes)
1267594
def get_all_thread_ids(self):
        
        json = self._get_json(self._url.thread_list())
        return [thread['no'] for page in json for thread in page['threads']]
952088
def get_all_incomings(chebi_ids):
    ''''''
    all_incomings = [get_incomings(chebi_id) for chebi_id in chebi_ids]
    return [x for sublist in all_incomings for x in sublist]
656723
public java.util.List<String> getCustomSecurityGroupIds() {
        if (customSecurityGroupIds == null) {
            customSecurityGroupIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return customSecurityGroupIds;
    }
290901
def get_ids(cs):
    """"""
    records = []
    for c in cs:
        records.append({k: c[k] for k in c if k in {'names', 'labels'}})
    return records
41573
def ids(self):
        """"""
        as_list = [seq.description.split()[0] for seq in self]
        as_set = frozenset(as_list)
        assert len(as_set) == len(as_list)
        return as_set
267315
def filter_webapp_attack(df, process_time):
    
    result = []
    track = []
    for o in df:
        if 'METHODOLOGY - WEB APP ATTACK' in o['message']:
            track.append(o)
        else:
            result.append(o)
    trackfile = open('tracking_webAppAttack_' + process_time + '.txt', 'w')
    numskip = 1
    for item in track:
        trackfile.write("\n\n**** {:d}: Display ID {} ****\n\n{}".format(numskip, item['displayId'], item))
        numskip += 1
    return result
464006
def get_all_targets(self):
        """"""
        result = []
        for batch in self.batches:
            result.extend(batch.targets)
        return result
795815
def get_ids(self, start=0, rows=1000, **query_dict):
        """"""
        resp_dict = self._get_query(start=start, rows=rows, **query_dict)
        return {
            'matches': resp_dict['response']['numFound'],
            'start': start,
            'ids': [d['id'] for d in resp_dict['response']['docs']],
        }