:calls: `PUT /user/following/:user <http://developer.github.com/v3/users/followers>`_
        :param following: :class:`github.NamedUser.NamedUser`
        :rtype: None
175704
def add_to_following(self, following):
        
        assert isinstance(following, github.NamedUser.NamedUser), following
        headers, data = self._requester.requestJsonAndCheck(
            "PUT",
            "/user/following/" + following._identity
        )
627782
def follow_user(self, user, delegate):
        
        parser = txml.Users(delegate)
        return self.__postPage('/friendships/create/%s.xml' % (user), parser)
890548
public function followers(string $following, string $startFollower = null, string $followType = null, int $limit = null)
    {
        $startFollower = is_null($startFollower) ? ''     : $startFollower;
        $followType    = is_null($followType)    ? 'blog' : $followType;
        $limit         = is_null($limit)         ? 10     : $limit;

        $request = [
            'route' => 'get_followers',
            'query' =>
                [
                    'following'     => $following,
                    'startFollower' => $startFollower,
                    'followType'    => $followType,
                    'limit'         => $limit,
                ]
        ];

        return parent::call($request);
    }
842941
def unfollow(user, obj):
    
    try:
        follow = Follow.objects.get_follows(obj).get(user=user)
        follow.delete()
        return follow 
    except Follow.DoesNotExist:
        pass
631830
function NearbyUser (username, identifier) {
  var self = this
  if (!(self instanceof NearbyUser)) return new NearbyUser(username, identifier)

  self.username = username
  self.identifier = identifier
}
12164
public void follow(String blogName) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("url", JumblrClient.blogUrl(blogName));
        requestBuilder.post("/user/follow", map);
    }
88869
def add_user(self, attrs):
        
        username = attrs[self.key]
        if username in self.users:
            raise UserAlreadyExists(username, self.backend_name)
        self.users[username] = attrs
        self.users[username]['groups'] = set([])
1315726
def add_to_public_members(self, public_member):
        
        assert isinstance(public_member, github.NamedUser.NamedUser), public_member
        headers, data = self._requester.requestJsonAndCheck(
            "PUT",
            self.url + "/public_members/" + public_member._identity
        )
933096
function(userObjectId) {
        if (!userObjectId || !_.isString(userObjectId)) {
          throw new Error('Invalid user object id.');
        }
        var query = new AV.FriendShipQuery('_Follower');
        query._friendshipTag = 'follower';
        query.equalTo(
          'user',
          AV.Object.createWithoutData('_User', userObjectId)
        );
        return query;
      }
1060334
public void add(Endpoint follower, long lastLogIndex) {
        assert !followerStates.containsKey(follower) : "Already known follower " + follower;
        followerStates.put(follower, new FollowerState(0L, lastLogIndex + 1));
    }
880128
def get_followx_users(html)
      users = []

      Nokogiri::HTML(html).css('.follow_section').each do |section|
        listener_name = section.css('.listener_name').first
        webname = listener_name['webname']

        # Remove any 'spans with a space' that sometimes appear with special characters.
        listener_name.css('span').each(&:remove)
        name = listener_name.text.strip

        href = section.css('a').first['href']

        users << { name: name, webname: webname, href: href }
      end

      users
    end
1016786
def get_followers(self, first_user_id=None):
        
        params = {"access_token": self.token}
        if first_user_id:
            params["next_openid"] = first_user_id
        return self.get(
            "https://api.weixin.qq.com/cgi-bin/user/get", params=params
        )
885520
def follow(self, user_id, notify=False):
        
        try:
            return User(self._client.create_friendship(user_id=user_id, follow=notify)._json)
        except TweepError as e:
            if e.api_code in [TWITTER_ACCOUNT_SUSPENDED_ERROR]:
                return self.get_user(user_id)
            raise
1192628
def new(self, user, name, description=None):
        
        uri = self.client.remote + '/users/{0}/feeds'.format(user)

        data = {
            'feed': {
                'name': name,
                'description': description
            }
        }

        resp = self.client.post(uri, data)
        return resp
239894
def __addUser(self, new_user):
        
        self.__lockReadAddUser.acquire()
        if new_user not in self.__cityUsers and \
                new_user not in self.__excludedUsers:
            self.__lockReadAddUser.release()
            self.__logger.debug("__addUser: Adding " + new_user)
            self.__cityUsers.add(new_user)

            myNewUser = GitHubUser(new_user)
            myNewUser.getData()
            myNewUser.getRealContributions()

            userLoc = myNewUser.location
            if not any(s in userLoc for s in self.__excludedLocations):
                self.__processedUsers.append(myNewUser)
        else:
            self.__logger.debug("__addUser: Excluding " + new_user)
            self.__lockReadAddUser.release()
1042403
def get_followers(self):
        
        return github.PaginatedList.PaginatedList(
            github.NamedUser.NamedUser,
            self._requester,
            "/user/followers",
            None
        )
359253
def put(self, request, bot_id, hook_id, id, format=None):
        
        bot = self.get_bot(bot_id, request.user)
        hook = self.get_hook(hook_id, bot, request.user)
        recipient = self.get_recipient(id, hook, request.user)
        serializer = self.serializer(recipient, data=request.data)
        
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)

        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)