Endpoint: /album/<id>/view.json

        Requests all properties of an album.
        Returns the requested album object.
962641
def view(self, album, **kwds):
        
        result = self._client.get("/album/%s/view.json" %
                                  self._extract_id(album),
                                  **kwds)["result"]
        return Album(self._client, result)
826083
def get_artist_songs(self, id_, sort='title', per_page=20, page=1):
        """"""
        endpoint = "artists/{id}/songs".format(id=id_)
        params = {'sort': sort, 'per_page': per_page, 'page': page}
        return self._make_request(endpoint, params_=params)
1296095
def get_tagged_albums(self, tag, limit=None, cacheable=True):
        """"""

        params = self._get_params()
        params["tag"] = tag
        params["taggingtype"] = "album"
        if limit:
            params["limit"] = limit
        doc = self._request(self.ws_prefix + ".getpersonaltags", cacheable, params)
        return _extract_albums(doc, self.network)
632005
def download_album_by_id(self, album_id, album_name):
        

        try:
            # use old api
            songs = self.crawler.get_album_songs(album_id)
        except RequestException as exception:
            click.echo(exception)
        else:
            folder = os.path.join(self.folder, album_name)
            for song in songs:
                self.download_song_by_id(song.song_id, song.song_name, folder)
141502
def get_details(artist_id, options={})
      api_response = @api_client.make_api_request(:GET, "artist/details", {:artistId => artist_id}, options)
      @api_client.artist_digestor.from_xml_doc(api_response.item_xml("artist"))
    end
232409
def getHeavyRotation(user=nil,type=nil,friends=nil,limit=nil,extras=nil)
      method = 'getHeavyRotation'
      cls = TODO
      if type == 'artist'
        cls = Artist
      elsif type == 'album'
        cls = Album
      end
      args = {}
      args[:user] = user if user
      args[:type] = type if type
      args[:friends] = friends if friends
      args[:limit] = limit if limit
      args[:extras] = extras if extras
      return_object cls,method,args
    end
545799
def get(request):
    
    res = Result()
    obj, created = UserPref.objects.get_or_create(user=request.user, defaults={'data': json.dumps(DefaultPrefs.copy())})

    data = obj.json()
    data['subscriptions'] = [_.json() for _ in GallerySubscription.objects.filter(user=request.user)]

    res.append(data)

    return JsonResponse(res.asDict())
210140
def get_album(self):
        """"""

        doc = self._request(self.ws_prefix + ".getInfo", True)

        albums = doc.getElementsByTagName("album")

        if len(albums) == 0:
            return

        node = doc.getElementsByTagName("album")[0]
        return Album(_extract(node, "artist"), _extract(node, "title"), self.network)
631978
def files
      result = form.select_files.map { |label, id| { id: id, text: label } }
      render json: result
    end
1172264
def get_submissions(self, limit=None):
        """"""
        url = (self._imgur._base_url + "/3/account/{0}/submissions/"
               "{1}".format(self.name, '{}'))
        resp = self._imgur._send_request(url, limit=limit)
        return [_get_album_or_image(thing, self._imgur) for thing in resp]
229891
def img_search_bing(album):
    '''  '''

    setup()

    album = album + " Album Art"

    api_key = "Key"
    endpoint = "https://api.cognitive.microsoft.com/bing/v5.0/images/search"
    links_dict = {}

    headers = {'Ocp-Apim-Subscription-Key': str(BING_KEY)}
    param = {'q': album, 'count': '1'}

    response = requests.get(endpoint, headers=headers, params=param)
    response = response.json()

    key = 0
    try:
        for i in response['value']:
            links_dict[str(key)] = str((i['contentUrl']))
            key = key + 1

        return links_dict["0"]
        
    except KeyError:
        return None
475236
def album_primary_image_url(self):
    ''''''
    path = '/Items/{}/Images/Primary'.format(self.album_id)
    return self.connector.get_url(path, attach_api_key=False)
831556
def image(id, options={})
      params = options
      get(surl('image') + id, params).body
    end
704368
def album(self):
        
        if not self._album:
            self._album = Album(self._album_id, self._album_name,
                                self._artist_id, self._artist_name,
                                self._cover_url, self._connection)
        return self._album
1155997
def _get_data(self, file_id):
    
        '''  '''
        
        title = '%s._get_data' % self.__class__.__name__
        
    # request file data
        try:
            record_data = self.drive.get_media(fileId=file_id).execute()
        except:
            raise DriveConnectionError(title)
        
        return record_data
1269190
def get_value(self, visual_property):
        
        res = requests.get(self.url + '/' + visual_property)
        return res.json()['value']
799261
def list(self, **kwds):
        
        albums = self._client.get("/albums/list.json", **kwds)["result"]
        albums = self._result_to_list(albums)
        return [Album(self._client, album) for album in albums]