Returns a list of actors that the user identified by ``user_id``
    is following (eg who im following).
354183
def following(request, user_id, flag):
    
    instance = get_object_or_404(USER_MODEL, pk=user_id)
    flag = flag or ''
    return render(
        request,
        'actstream/following.html',
        {
            'following': models.following(instance, flag=flag),
            'user': instance,
        }
    )
314040
def list_subscribers(self, list_id):
        
        return [User(user._json) for user in self._client.list_subscribers(list_id=list_id)]
161228
def get_followers(self):
        
        return github.PaginatedList.PaginatedList(
            NamedUser,
            self._requester,
            self.url + "/followers",
            None
        )
717820
def get_likes(self):
        
        from .users import User
        return self._session.fetch_items('likes.getList', User._get_user, count=100, type='post', owner_id=self.from_id, item_id=self.id)
1312259
def following(self, account=None, limit=100):
        ''' 
        '''
        if not account:
            account = self.mainaccount
        followingnames = []
        try:
            self.followed = self.steem_instance().get_following(account, 
                '', 'blog', limit)
        except Exception as e:
            self.msg.error_message(e)
            return False
        else:
            for a in self.followed:
                followingnames.append(a['following'])
            return followingnames
1133721
def tag_users(self, tag_id, open_id_list):
        
        return self.post(
            url="https://api.weixin.qq.com/cgi-bin/tags/members/batchtagging",
            data={
                "openid_list": open_id_list,
                "tagid": tag_id
            }
        )
483086
def followers(self):
        
        from .author import Author, ANONYMOUS
        self._make_soup()
        gotten_data_num = 20
        data = {
            '_xsrf': self.xsrf,
            'start': '',
            'offset': 0
        }
        while gotten_data_num == 20:
            res = self._session.post(
                Topic_Get_More_Follower_Url.format(self.id), data=data)
            j = res.json()['msg']
            gotten_data_num = j[0]
            data['offset'] += gotten_data_num
            soup = BeautifulSoup(j[1])
            divs = soup.find_all('div', class_='zm-person-item')
            for div in divs:
                h2 = div.h2
                url = Zhihu_URL + h2.a['href']
                name = h2.a.text
                motto = h2.parent.div.text.strip()
                try:
                    yield Author(url, name, motto, session=self._session)
                except ValueError:  # invalid url
                    yield ANONYMOUS
            data['start'] = int(re_get_number.match(divs[-1]['id']).group(1))
787752
def users(self):
        
        if self._users is None:
            self._users = UserList(self._version, service_sid=self._solution['sid'], )
        return self._users
1047358
def getVerificators(self):
        
        verifiers = list()
        actions = ["verify", "multi_verify"]
        for event in wf.getReviewHistory(self):
            if event['action'] in actions:
                verifiers.append(event['actor'])
        sorted(verifiers, reverse=True)
        return verifiers
460326
def followers(request, content_type_id, object_id, flag):
    
    ctype = get_object_or_404(ContentType, pk=content_type_id)
    instance = get_object_or_404(ctype.model_class(), pk=object_id)
    flag = flag or ''

    return render(
        request,
        'actstream/followers.html',
        {
            'followers': models.followers(instance, flag=flag),
            'actor': instance,
        }
    )
1011998
def user(request, username):
    
    instance = get_object_or_404(
        USER_MODEL,
        **{'is_active': True, username_field: username}
    )
    return render(
        request,
        'actstream/actor.html',
        context={
            'ctype': ContentType.objects.get_for_model(USER_MODEL),
            'actor': instance, 'action_list': models.user_stream(instance)
        }
    )
522988
def get_watchers(self, username, offset=0, limit=10):

        

        response = self._req('/user/watchers/{}'.format(username), {
            'offset' : offset,
            'limit' : limit
        })

        watchers = []

        for item in response['results']:
            w = {}
            w['user'] = User()
            w['user'].from_dict(item['user'])
            w['is_watching'] = item['is_watching']
            w['lastvisit'] = item['lastvisit']
            w['watch'] = {
                "friend" : item['watch']['friend'],
                "deviations" : item['watch']['deviations'],
                "journals" : item['watch']['journals'],
                "forum_threads" : item['watch']['forum_threads'],
                "critiques" : item['watch']['critiques'],
                "scraps" : item['watch']['scraps'],
                "activity" : item['watch']['activity'],
                "collections" : item['watch']['collections']
            }

            watchers.append(w)

        return {
            "results" : watchers,
            "has_more" : response['has_more'],
            "next_offset" : response['next_offset']
        }
1314252
function getFollowers(T, user_id, max_followers, finish) {
  return getFollowersIt(T, user_id, [], -1, max_followers, finish);
}
407795
def list_users(self, user=None):
    '''
    ''' 
    from expfactory.database.models import Participant
    participants = Participant.query.all()
    users = []
    for user in participants:
        users.append(self.print_user(user))
    return users
450020
def get_users_by_ids(self, user_ids):
        
        urls = [urljoin(self.user_url, F"{i}.json") for i in user_ids]
        result = self._run_async(urls=urls)
        return [User(r) for r in result if r]
1259366
def follow(type, ids)
      params = { type: type, ids: Array.wrap(ids).join(',') }
      run(:put, "/v1/me/following", [204], params)
    end
627782
def follow_user(self, user, delegate):
        
        parser = txml.Users(delegate)
        return self.__postPage('/friendships/create/%s.xml' % (user), parser)