Returns a list of all media from all library sections.
            This may be a very large dataset to retrieve.
1501
def all(self, **kwargs):
        
        items = []
        for section in self.sections():
            for item in section.all(**kwargs):
                items.append(item)
        return items
210631
def all(self):
        
        datasets = []

        query = text("""
            SELECT vid
            FROM dataset_index;""")

        for result in self.execute(query):
            res = DatasetSearchResult()
            res.vid = result[0]
            res.b_score = 1
            datasets.append(res)
        return datasets
749629
function getLibraries() {
	var results = [];

	if (extensions && extensions.hasOwnProperty('libraries')) {
		var sourceArray = extensions.libraries;

		for (index = 0; index < sourceArray.length; ++index) {
		    results.push(sourceArray[index]);
		}
	}

	return results;
}
437211
def find_all(self):
        
        with self._database:
            rows = self._database.execute('SELECT name, year, director '
                                          'FROM movies')
            return [self._movie_model(*row) for row in rows]
447427
def get_collections(self):
        
        collections = []
        for result in self._get_collections():
            collections.append(result['collection'])

        return collections
701469
def _get_media(media_types):
    """"""
    get_mapped_media = (lambda x: maps.VIRTUAL_MEDIA_TYPES_MAP[x]
                        if x in maps.VIRTUAL_MEDIA_TYPES_MAP else None)
    return list(map(get_mapped_media, media_types))
1220246
def all(self):
        
        partitions = []

        query = text("""
            SELECT dataset_vid, vid
            FROM partition_index;""")

        for result in self.execute(query):
            dataset_vid, vid = result
            partitions.append(PartitionSearchResult(dataset_vid=dataset_vid, vid=vid, score=1))
        return partitions
776398
def all(self):
        
        partitions = []
        for partition in self.index.searcher().documents():
            partitions.append(
                PartitionSearchResult(dataset_vid=partition['dataset_vid'], vid=partition['vid'], score=1))
        return partitions
820593
def files(
            self):
        
        relatedFilesResultsList = []
        relatedFilesResultsList[:] = [dict(l)
                                      for l in self.relatedFilesResultsList]
        return relatedFilesResultsList
1276012
def get_gallery_folder_list(self, scope='content/read'):
        
        folder_list = _get(
            token=self.oauth.get_user_token(scope),
            uri='/user/media'
        )
        try:
            return json.loads(folder_list)
        except:
            raise MxitAPIException('Error parsing gallery folder list')
376845
def all(self):
        
        url = "{url_base}/resource/{pid}/files/".format(url_base=self.hs.url_base,
                                                                 pid=self.pid)
        r = self.hs._request('GET', url)
        return r
1317533
def get_labs(format):
    """"""

    labs = []

    # Get the first page of data
    wiki = MediaWiki(makeinitaly__foundation_api_url)
    wiki_response = wiki.call(
        {'action': 'query',
         'list': 'categorymembers',
         'cmtitle': 'Category:Italian_FabLabs',
         'cmlimit': '500'})
    if "query-continue" in wiki_response:
        nextpage = wiki_response[
            "query-continue"]["categorymembers"]["cmcontinue"]

    urls = []
    for i in wiki_response["query"]["categorymembers"]:
        urls.append(i["title"].replace(" ", "_"))

    # Load all the Labs in the first page
    for i in urls:
        current_lab = get_single_lab(i)
        labs.append(current_lab)

    # Load all the Labs from the other pages
    while "query-continue" in wiki_response:
        wiki = MediaWiki(makeinitaly__foundation_api_url)
        wiki_response = wiki.call({'action': 'query',
                                   'list': 'categorymembers',
                                   'cmtitle': 'Category:Hackerspace',
                                   'cmlimit': '500',
                                   "cmcontinue": nextpage})

        urls = []
        for i in wiki_response["query"]["categorymembers"]:
            urls.append(i["title"].replace(" ", "_"))

        # Load all the Labs
        for i in urls:
            current_lab = get_single_lab(i, data_format)
            labs.append(current_lab)

        if "query-continue" in wiki_response:
            nextpage = wiki_response[
                "query-continue"]["categorymembers"]["cmcontinue"]
        else:
            break

    # Transform the list into a dictionary
    labs_dict = {}
    for j, k in enumerate(labs):
        labs_dict[j] = k.__dict__

    # Return a dictiornary / json
    if format.lower() == "dict" or format.lower() == "json":
        output = labs_dict
    # Return a geojson
    elif format.lower() == "geojson" or format.lower() == "geo":
        labs_list = []
        for l in labs_dict:
            single = labs_dict[l].__dict__
            single_lab = Feature(
                type="Feature",
                geometry=Point((single["latitude"], single["longitude"])),
                properties=single)
            labs_list.append(single_lab)
        output = dumps(FeatureCollection(labs_list))
    # Return a Pandas DataFrame
    elif format.lower() == "pandas" or format.lower() == "dataframe":
        output = {}
        for j in labs_dict:
            output[j] = labs_dict[j].__dict__
        # Transform the dict into a Pandas DataFrame
        output = pd.DataFrame.from_dict(output)
        output = output.transpose()
    # Return an object
    elif format.lower() == "object" or format.lower() == "obj":
        output = labs
    # Default: return an object
    else:
        output = labs
    # Return a proper json
    if format.lower() == "json":
        output = json.dumps(labs_dict)
    return output
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
251398
def libvlc_media_discoverer_media_list(p_mdis):
    '''
    '''
    f = _Cfunctions.get('libvlc_media_discoverer_media_list', None) or \
        _Cfunction('libvlc_media_discoverer_media_list', ((1,),), class_result(MediaList),
                    ctypes.c_void_p, MediaDiscoverer)
    return f(p_mdis)
505622
def getall(self):
        
        vlans_re = re.compile(r'(?<=^vlan\s)(\d+)', re.M)

        response = dict()
        for vid in vlans_re.findall(self.config):
            response[vid] = self.get(vid)
        return response
499249
def get_all(self, path, data=None, limit=100):
        """"""
        return ListResultSet(path=path, data=data or {}, limit=limit)
675053
def download_slides(self):
        
        return self.presentation.client.download_all(self.presentation.metadata['slides'], self.tmp_dir)