Get the current user’s followed artists.<br/>
[Response format](https://developer.spotify.com/documentation/web-api/reference/follow/get-followed/#response-format)
@example ../../docs/User/UserArtists.md
179764
function UserArtists(props) {
    let url = BASE_URL;
    let options = { ...props.options, type: 'artist' };

    return (
        <ApiRequest url={url} options={options}>
            {(data, loading, error) => props.children(data, loading, error)}
        </ApiRequest>
    );
}
1132007
public function getLovedTracks($methodVars)
    {
        // Check for required variables
        if (!empty($methodVars['user'])) {
            $vars = array(
                'method' => 'user.getlovedtracks',
                'api_key' => $this->auth->apiKey
            );
            $vars = array_merge($vars, $methodVars);

            if ($call = $this->apiGetCall($vars)) {
                if (count($call->lovedtracks->track) > 0) {
                    $i = 0;
                    foreach ($call->lovedtracks->track as $track) {
                        $lovedTracks[$i]['name'] = (string) $track->name;
                        $lovedTracks[$i]['mbid'] = (string) $track->mbid;
                        $lovedTracks[$i]['url'] = (string) $track->url;
                        $lovedTracks[$i]['date'] = (string) $track->date['uts'];
                        $lovedTracks[$i]['artist']['name'] = (string) $track->artist->name;
                        $lovedTracks[$i]['artist']['mbid'] = (string) $track->artist->mbid;
                        $lovedTracks[$i]['artist']['url'] = (string) $track->artist->url;
                        $lovedTracks[$i]['images']['small'] = (string) $track->image[0];
                        $lovedTracks[$i]['images']['medium'] = (string) $track->image[1];
                        $lovedTracks[$i]['images']['large'] = (string) $track->image[2];
                        $i++;
                    }

                    return $lovedTracks;
                } else {
                    throw new NoResultsException('This user has no loved tracks');
                }
            } else {
                return false;
            }
        } else {
            throw new InvalidArgumentException('You must include artist variable in the call for this method');
        }
    }
776134
def followers(user_name, repo_name, params={})
      _update_user_repo_params(user_name, repo_name)
      _validate_user_repo_params(user, repo) unless user? && repo?
      normalize! params

      response = get_request("/1.0/repositories/#{user}/#{repo.downcase}/followers/", params)
      return response unless block_given?
      response.each { |el| yield el }
    end
519595
public Observable<ArrayList<SoundCloudTrack>> getArtistTracks() {
        checkState();
        if (mCacheRam.tracks.size() != 0) {
            return Observable.create(new Observable.OnSubscribe<ArrayList<SoundCloudTrack>>() {
                @Override
                public void call(Subscriber<? super ArrayList<SoundCloudTrack>> subscriber) {
                    subscriber.onNext(mCacheRam.tracks);
                    subscriber.onCompleted();
                }
            });
        } else {
            return mRetrofitService.getUserTracks(mArtistName)
                    .map(RxParser.PARSE_USER_TRACKS)
                    .map(cacheTracks());
        }
    }
679133
def artist_infos(self, artist_id):
        
        action = uri + '/artist/' + str(artist_id)
        data = self.request('GET', action)
        return data
1208733
public function getArtist($artistId)
    {
        $headers = $this->authHeaders();

        $artistId = $this->uriToId($artistId, 'artist');
        $uri = '/v1/artists/' . $artistId;

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

        return $this->lastResponse['body'];
    }
518907
async def follow_user(self, request):
        """"""
        username = request.match_info['username']
        session = await get_session(request)
        user_id = session.get('user_id')

        if not user_id:
            raise web.HTTPNotAuthorized()

        whom_id = await db.get_user_id(self.mongo.user, username)

        if whom_id is None:
            raise web.HTTPFound()

        await self.mongo.follower.update(
            {'who_id': ObjectId(user_id)},
            {'$push': {'whom_id': whom_id}}, upsert=True)

        return redirect(request, 'user_timeline', parts={"username": username})
999710
def getArtistsInCollection(user=nil,start=nil,count=nil,sort=nil,
                               query=nil,extras=nil)
      method = 'getArtistsInCollection'
      type = Artist
      args = {}
      args[:user] = user if user
      args[:start] = start if start
      args[:count] = count if count
      args[:sort] = sort if sort
      args[:query] = query if query
      args[:extras] = extras if extras
      auth = !!user
      return_object type,method,args,auth
    end
151133
def getAlbumsForArtistInCollection(artist,user=nil,extras=nil)
      method = 'getAlbumsForArtistInCollection'
      type = Album
      args = {:artist=>artist}
      args[:user] = user if user
      args[:extras] = extras if extras
      auth = !!user
      return_object type,method,args,auth
    end
1263576
@Override
    public InstagramPaginatingResponse<InstagramUser> getFollowing(String accessToken,
                                                                   String userId) throws InstagramError {
        return instagramEndpoints.getFollowing(accessToken, userId);
    }
1263546
def get_artists(self, search, start=0, max_items=100):
        
        return self.get_music_service_information('artists', search, start,
                                                  max_items)
460646
def is_following(self, user, obj):
        
        if isinstance(user, AnonymousUser):
            return False        
        return 0 < self.get_follows(obj).filter(user=user).count()
373453
private static Node checkFollowedIdentifier(
			final HttpServletRequest request,
			final DeleteFollowResponse response) {
		final String followedId = request
				.getParameter(ProtocolConstants.Parameters.Delete.Follow.FOLLOWED_IDENTIFIER);
		if (followedId != null) {
			final Node followed = NeoUtils.getUserByIdentifier(followedId);
			if (followed != null) {
				return followed;
			}
			response.followedIdentifierInvalid(followedId);
		} else {
			response.followedIdentifierMissing();
		}

		return null;
	}
128607
def get_tagged_artists(self, tag, limit=None):
        """"""

        params = self._get_params()
        params["tag"] = tag
        params["taggingtype"] = "artist"
        if limit:
            params["limit"] = limit
        doc = self._request(self.ws_prefix + ".getpersonaltags", True, params)
        return _extract_artists(doc, self.network)
382490
def follow(self, something, follow=True):
        
        from .question import Question
        from .topic import Topic
        from .collection import Collection
        if isinstance(something, Author):
            if something.url == self.url:
                return False
            data = {
                '_xsrf': something.xsrf,
                'method': '	follow_member' if follow else 'unfollow_member',
                'params': json.dumps({'hash_id': something.hash_id})
            }
            res = self._session.post(Follow_Author_Url, data=data)
            return res.json()['r'] == 0
        elif isinstance(something, Question):
            data = {
                '_xsrf': something.xsrf,
                'method': 'follow_question' if follow else 'unfollow_question',
                'params': json.dumps({'question_id': str(something.qid)})
            }
            res = self._session.post(Follow_Question_Url, data=data)
            return res.json()['r'] == 0
        elif isinstance(something, Topic):
            data = {
                '_xsrf': something.xsrf,
                'method': 'follow_topic' if follow else 'unfollow_topic',
                'params': json.dumps({'topic_id': something.tid})
            }
            res = self._session.post(Follow_Topic_Url, data=data)
            return res.json()['r'] == 0
        elif isinstance(something, Collection):
            data = {
                '_xsrf': something.xsrf,
                'favlist_id': something.cid
            }
            res = self._session.post(
                Follow_Collection_Url if follow else Unfollow_Collection_Url,
                data=data)
            return res.json()['r'] == 0
        else:
            raise ValueError('argument something need to be '
                             'zhihu.Author, zhihu.Question'
                             ', Zhihu.Topic or Zhihu.Collection object.')
1088210
def similar(self):
        
        if self._similar is None:
            self._similar = [
                Artist(artist['ArtistID'], artist['Name'], self._connection)
                for artist in self._connection.request(
                    'artistGetSimilarArtists',
                    {'artistID': self.id},
                    self._connection.header('artistGetSimilarArtists'))[1]['SimilarArtists']]
        return iter(self._similar)
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)