Fetches list of all contacts
        This will return chats with people from the address book only
        Use get_all_chats for all chats

        :return: List of contacts
        :rtype: list[Contact]
197284
def get_contacts(self):
        
        all_contacts = self.wapi_functions.getAllContacts()
        return [Contact(contact, self) for contact in all_contacts]
334446
def get_all(self):
        
        components = []
        
        self._lock.acquire()
        try:
            for reference in self._references:
                components.append(reference.get_component())
        finally:
            self._lock.release()

        return components
318862
def _get_all(self):
        
        return [self._to_dict(row) for row in models.User.objects.all()]
1022556
private static List<ContactDetails> fetchDataList() {
		List<ContactDetails> list = new ArrayList<>();
		list.add(new ContactDetails("David", "1234", new String[]{"a", "b"}));
		list.add(new ContactDetails("Jun", "1111", new String[]{"c"}));
		list.add(new ContactDetails("Martin", null, new String[]{"b"}));
		return list;
	}
1260086
def getConferenceStats(self):
        
        if not self.hasConference():
            return None
        if self.checkVersion('1.6'):
            cmd = "meetme list"
        else:
            cmd = "meetme"
        cmdresp = self.executeCommand(cmd)

        info_dict = dict(active_conferences = 0, conference_users = 0)
        for line in cmdresp.splitlines():
            mobj = re.match('\w+\s+0(\d+)\s', line)
            if mobj:
                info_dict['active_conferences'] += 1
                info_dict['conference_users'] += int(mobj.group(1))

        return info_dict
1137328
public static function indexcontacts()
    {
        $db = self::db();

        // iterate over all users
        $sql_result = $db->query("SELECT `user_id` FROM " . $db->table_name('users', true) . " ORDER BY `user_id`");
        while ($sql_result && ($sql_arr = $db->fetch_assoc($sql_result))) {
            echo "Indexing contacts for user " . $sql_arr['user_id'] . "...\n";

            $contacts = new rcube_contacts($db, $sql_arr['user_id']);
            $contacts->set_pagesize(9999);

            $result = $contacts->list_records();
            while ($result->count && ($row = $result->next())) {
                unset($row['words']);
                $contacts->update($row['ID'], $row);
            }
        }

        echo "done.\n";
    }
818720
def attend_pendings(self):
        
        chats_attended = []
        pending_chats = Chat.pending.all()
        for pending_chat in pending_chats:
            free_agent = self.strategy.free_agent() 
            if free_agent:
                pending_chat.attend_pending(free_agent, self)
                pending_chat.save()
                chats_attended.append(pending_chat)
            else:
                break
        return chats_attended
1355917
def _get_chat(self) -> Dict:
        

        if 'callback_query' in self._update:
            query = self._update['callback_query']
            if 'message' in query:
                return query['message']['chat']
            else:
                return {'id': query['chat_instance']}
        elif 'inline_query' in self._update:
            return patch_dict(
                self._update['inline_query']['from'],
                is_inline_query=True,
            )
        elif 'message' in self._update:
            return self._update['message']['chat']
960891
def get_conversations(self):
        
        cs = self.data["data"]
        res = []
        for c in cs:
            res.append(Conversation(c))
        return res
1309500
def conversations(self):
        
        body = {
            "conversation_type": self.conversation_type,
            "audience_definition": self.audience_definition,
            "targeting_inputs": self.targeting_inputs
        }
        return self.__get(account=self.account, client=self.account.client, params=json.dumps(body))
1299788
def get_addresses(message: list) -> list:
    
    # Need the address so that we know who to send the message back to
    addresses = []
    for address in message:
        # if we hit a blank string, then we've got all the addresses
        if address == b'':
            break
        addresses.append(address)

    return addresses
60740
def fetch_friend_ids(self, user):
        
        friends = self.fetch_friends(user)

        return [friend['ns1_email']['address']
                for friend in friends
                if 'ns1_email' in friend]
415223
def get_my_contacts(self):
        
        my_contacts = self.wapi_functions.getMyContacts()
        return [Contact(contact, self) for contact in my_contacts]
1351346
def conversations(self, max_id=None, min_id=None, since_id=None, limit=None):
        
        if max_id != None:
            max_id = self.__unpack_id(max_id)
        
        if min_id != None:
            min_id = self.__unpack_id(min_id)
            
        if since_id != None:
            since_id = self.__unpack_id(since_id)            
        
        params = self.__generate_params(locals())
        return self.__api_request('GET', "/api/v1/conversations/", params)
1091850
def get_persons(self):
        
        cs = self.data["to"]["data"]
        res = [] 
        for c in cs:
            res.append(c["name"])
        return res
678451
def getEmailAddresses(self):
        
        return self.store.query(
            EmailAddress,
            EmailAddress.person == self).getColumn('address')
491938
def get_contacts(self, issue):
        
        # If the resources has been deleted, just return an empty list, to trigger issue deletion without notification
        if not issue.resource:
            return []

        account_contacts = issue.resource.account.contacts
        try:
            resource_owners = issue.resource.get_owner_emails()
            # Double check get_owner_emails for it's return value
            if type(resource_owners) is list:
                for resource_owner in resource_owners:
                    account_contacts.append({'type': 'email', 'value': resource_owner})
        except AttributeError:
            pass
        return account_contacts