https://vk.com/dev/photos.getAll
176777
def _get_photos(session, user_or_group_id):
        
        response = session.fetch_items("photos.getAll", Photo.from_json, count=200, owner_id=user_or_group_id)
        return response
1234554
def get_images(self, limit=None):
        """"""
        url = (self._imgur._base_url + "/3/account/{0}/"
               "images/{1}".format(self.name, '{}'))
        resp = self._imgur._send_request(url, limit=limit)
        return [Image(img, self._imgur) for img in resp]
1035195
async function getAll(options) {
    const data = {};
    const keys = filterPaths(await module.exports.keys(), options);

    for (let key of keys) {
      data[key] = await module.exports.get(key, {
        before: options.before,
        after: options.after,
      });
    }

    await Promise.all(keys);

    return data;
  }
176764
def _get_vqa_v2_image_raw_dataset(directory, image_root_url, image_urls):
  """"""
  for url in image_urls:
    filename = os.path.basename(url)
    download_url = os.path.join(image_root_url, url)
    path = generator_utils.maybe_download(directory, filename, download_url)
    unzip_dir = os.path.join(directory, filename.strip(".zip"))
    if not tf.gfile.Exists(unzip_dir):
      zipfile.ZipFile(path, "r").extractall(directory)
998049
def image_list(auth=None, **kwargs):
    '''
    
    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(**kwargs)
    return cloud.list_images(**kwargs)
451445
public function allRaw()
    {
        $query = $this->make(['translations'])
            ->select(
                'id',
                'name',
                'image',
                DB::raw('(SELECT COUNT(*) FROM `'.
                    DB::getTablePrefix().
                    'files` WHERE `gallery_id` = `'.
                    DB::getTablePrefix().
                    "galleries`.`id`) AS 'files_count'")
                )
            ->order();

        // Get
        return $query->get();
    }
595010
public static function photos()
    {
        if (!getConfig('sitemap.photos')) {
            return [];
        }

        $table = TableRegistry::get('MeCms.PhotosAlbums');
        $url = Cache::read('sitemap', $table->getCacheName());

        if (!$url) {
            $alias = $table->Photos->getAlias();

            $albums = $table->find('active')
                ->select(['id', 'slug'])
                ->contain($alias, function (Query $q) use ($alias) {
                    return $q->find('active')
                        ->select(['id', 'album_id', 'modified'])
                        ->order([sprintf('%s.modified', $alias) => 'DESC']);
                });

            if ($albums->isEmpty()) {
                return [];
            }

            $latest = $table->Photos->find('active')
                ->select(['modified'])
                ->order([sprintf('%s.modified', $alias) => 'DESC'])
                ->firstOrFail();

            //Adds albums index
            $url[] = self::parse(['_name' => 'albums'], ['lastmod' => $latest->modified]);

            foreach ($albums as $album) {
                //Adds the album
                $url[] = self::parse(['_name' => 'album', $album->slug], ['lastmod' => array_value_first($album->photos)->modified]);

                //Adds each photo
                foreach ($album->photos as $photo) {
                    $url[] = self::parse(
                        ['_name' => 'photo', 'slug' => $album->slug, 'id' => $photo->id],
                        ['lastmod' => $photo->modified]
                    );
                }
            }

            Cache::write('sitemap', $url, $table->getCacheName());
        }

        return $url;
    }
718559
def get_all(self, qry, tpl):
        '''  '''
        self.cur.execute(qry, tpl)
        result = self.cur.fetchall()
        return result
24987
function getAll(url, collection) {
    // Initialise array
    collection = typeof collection === 'undefined' ? [] : collection;

    return makeRequest(url).then(function (data) {
      // Add each item to array
      var length = data.results.length;
      for (var i = 0; i < length; ++i) {
        collection.push(data.results[i]);
      }

      if (data.next === null) {
        // Return on final page
        return collection;
      } else {
        return getAll(data.next, collection);
      }
    }).catch(function (err) {
      throw err;
    });
  }
476993
def get_albums(self, limit=None):
        
        url = (self._imgur._base_url + "/3/account/{0}/albums/{1}".format(self.name,
                                                                       '{}'))
        resp = self._imgur._send_request(url, limit=limit)
        return [Album(alb, self._imgur, False) for alb in resp]
1116357
async function getAllDocs() {
  // Restore docs in parent->child->grandchild order
  const allDocs = [
    ...(await models.settings.all()),
    ...(await models.workspace.all()),
    ...(await models.workspaceMeta.all()),
    ...(await models.environment.all()),
    ...(await models.cookieJar.all()),
    ...(await models.requestGroup.all()),
    ...(await models.requestGroupMeta.all()),
    ...(await models.request.all()),
    ...(await models.requestMeta.all()),
    ...(await models.response.all()),
    ...(await models.oAuth2Token.all()),
    ...(await models.clientCertificate.all()),
  ];

  return allDocs;
}
452388
def get_gallery_all(self, username='', offset=0, limit=10):
        
        if not username:
            raise DeviantartError('No username defined.')

        response = self._req('/gallery/all', {'username': username,
                                               'offset': offset,
                                               'limit': limit})

        deviations = []

        for item in response['results']:
            d = Deviation()
            d.from_dict(item)
            deviations.append(d)

        if "name" in response:
            name = response['name']
        else:
            name = None

        return {
            "results": deviations,
            "name": name,
            "has_more": response['has_more'],
            "next_offset": response['next_offset']
        }
1225659
def list_all():
    '''
    
    '''
    ret = []
    if _sd_version() >= 219:
        for line in _machinectl('list-images')['stdout'].splitlines():
            try:
                ret.append(line.split()[0])
            except IndexError:
                continue
    else:
        rootdir = _root()
        try:
            for dirname in os.listdir(rootdir):
                if os.path.isdir(os.path.join(rootdir, dirname)):
                    ret.append(dirname)
        except OSError:
            pass
    return ret
1151708
def all(self, res):
        ""
        B = get_backend()
        return B.get_objects(B.get_concrete(res))
1228531
public function listAll()
    {
        try {
            $return = [ ];
            $result = $this->getSoapClient()->ListImages();
            if ( isset($result->ListImagesResult) ) {
                $return = $this->getSoapClient()->backendListArrayToMultiAssocArray($result->ListImagesResult);
            }

            return $return;
        } catch ( SoapException $ex ) {
            throw new StatusException('Error while obtaining the list of all images' , $ex);
        }
    }
521507
def photos(page = 1, per_page = 10)
      params = {
        page:     page,
        per_page: per_page
      }

      list = JSON.parse(connection.get("/users/#{username}/photos", params).body)
      list.map do |photo|
        Unsplash::Photo.new photo.to_hash
      end
    end
43010
def get_images(self, obj):
        """"""
        return {str(i.tag): i.image.url for i in obj.images.all()}