Get a album.
https://developer.spotify.com/documentation/web-api/reference/albums/get-album/

@param string $albumId ID or Spotify URI of the album.

@return array|object The requested album. Type is controlled by `SpotifyWebAPI::setReturnType()`.
9201
public function getAlbum($albumId)
    {
        $headers = $this->authHeaders();

        $albumId = $this->uriToId($albumId, 'album');
        $uri = '/v1/albums/' . $albumId;

        $this->lastResponse = $this->request->api('GET', $uri, [], $headers);

        return $this->lastResponse['body'];
    }
182545
public function get($media_id)
    {
        if (!is_string($media_id)) {
            $this->setError('参数错误,媒体ID参数错误');

            return false;
        }

        $queryStr = [
            'media_id' => $media_id,
        ];

        $res = $this->_post('get_material', $queryStr);

        return $res;
    }
977491
def get_tracks_from_album(album_name):
    '''
    
    '''

    spotify = spotipy.Spotify()

    album = spotify.search(q='album:' + album_name, limit=1)
    album_id = album['tracks']['items'][0]['album']['id']
    results = spotify.album_tracks(album_id=str(album_id))
    songs = []
    for items in results['items']:
        songs.append(items['name'])

    return songs
206610
public function get_from_id(int $id) {
        $records = $this->get_from_ids([$id]);
        return count($records) ? array_shift($records) : null;
    }
931332
public function download($mediaId)
    {
        $response = $this->curl->post(self::DOWNLOAD.$this->access_token, json_encode([
                    'media_id' => $mediaId,
                ]
            )
        );
        $is_json = json_decode($response);
        if ($is_json) {
            return Response::json($is_json);
        } else {
            return $response;
        }
    }
298248
public function findOne($productId)
    {
        $this->useAlternateEndpoint = true;
        $this->queryParams['ProductIds'] = $productId;
        $this->addAllProductImages();
        $this->addAllShopLogos();
        $response = $this->send();
        $products = $response->getProducts();
        if (isset($products[0])) {
            return $products[0];
        }

        return null;
    }
1266925
public function getAsset($id)
    {
        $params = array( 'id' => $id );
        $params = $this->validator->validate($params);

        try {
            return $this->client->sendRequest('assets/{id}', $params, 'GET');
        } catch (\Exception $ex) {
            throw $ex;
        }
    }
736818
public function getRelist($itemId)
    {
        $item = Item::findOrFail($itemId);

        Session::forget('photos');

        foreach ($item->photos as $photo) {
            Session::push('photos', [
                'real_path' => $photo->getPath(),
                'filename'  => $photo->photoId,
            ]);
        }

        $categories = Category::leaves()->orderBy('category_id')->get();

        return view('mustard::item.new', [
            'item'       => $item,
            'categories' => $categories,
        ]);
    }
1099115
public function lookup($id) {
        if ($pos = strpos($id, ',')) {
            $id = substr($id, 0, $pos);
        }

        $cacheKey = 'volume_' . $id;

        if ($this->cache && $this->cache->has($cacheKey)) {
            $val = $this->cache->get($cacheKey);

            if (!$val instanceof Volume) {
                $val = new Volume($val);
            }

            return $val;
        }

        $res = $this->client->get($this->buildMasterUrl(self::DIR_LOOKUP), [
            'query' => [ 'volumeId' => $id ]
        ]);

        if ($res->getStatusCode() != 200) {
            throw new SeaweedFSException('Unexpected response when looking up volume: ' . $res->getStatusCode());
        }

        $body = json_decode((string) $res->getBody());

        $volume = new Volume($body);

        if ($this->cache) {
            $this->cache->put($cacheKey, $volume);
        }

        return $volume;
    }
231956
public function getById(string $recordId): JsonResponse
    {
        return $this->response->success('OK', $this->service->getUserById($recordId));
    }
374718
public function getLabel(int $labelId)
    {
        if ( ! $this->validateId($labelId)) {
            return false;
        }

        $result = $this->get('labels/' . $labelId);

        if (200 === $result->getStatusCode()) {
            return json_decode($result->getBody()->getContents());
        }

        return false;
    }
713754
public function getMaterial($mediaId)
    {
        $result = $this->httpGet(self::WECHAT_MATERIAL_GET_PREFIX, [
            'access_token' => $this->getAccessToken(),
            'media_id' => $mediaId
        ]);
        return !array_key_exists('errcode', $result) ? $result : false;
    }
578968
private function _getSession($sessionId)
    {
        if (is_null($this->_session)) {
            $this->_session = $this->_repository->find(array('sessionId' => $sessionId));
        }

        return $this->_session;
    }
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)
974807
public FTMusicArtist getMusicAlbum(String id) throws FanartTvException {
        URL url = ftapi.getImageUrl(BaseType.ALBUM, id);
        String page = requestWebPage(url);

        FTMusicArtist album = null;

        try {
            album = mapper.readValue(page, FTMusicArtist.class);
        } catch (IOException ex) {
            throw new FanartTvException(ApiExceptionType.MAPPING_FAILED, "Failed to get Music Album with ID " + id, url, ex);
        }

        return album;
    }
1278261
def album_infos(self, album_id):
        
        action = uri + '/album/' + str(album_id)
        data = self.request('GET', action)
        if data['code'] == 200:
            return data['album']
469541
public function get($id)
    {
        if (!is_string($id)) {
            throw new ContainerException('$id must be a string');
        }

        if (!isset($this->definitions[$id])) {
            throw new NotFoundException("Unresolvable ".$id);
        }

        return $this->definitions[$id];
    }