Follow a user.

        Set `reblogs` to False to hide boosts by the followed user.

        Returns a `relationship dict`_ containing the updated relationship to the user.
480884
def account_follow(self, id, reblogs=True):
        
        id = self.__unpack_id(id)
        params = self.__generate_params(locals())
        
        if params["reblogs"] == None:
            del params["reblogs"]
            
        url = '/api/v1/accounts/{0}/follow'.format(str(id))
        return self.__api_request('POST', url, params)
911485
def update(self, **kwargs):
        

        item = self._client['users/*/lists/*'].update(self.username, self.id, return_type='data', **kwargs)

        if not item:
            return False

        self._update(item)
        return True
21022
def update(self, uid):
        '''
        
        '''
        if self.userinfo.role[1] >= '3':
            pass
        else:
            return False
        post_data = self.get_post_data()

        post_data['user_name'] = self.get_current_user()

        if self.is_p:
            if MLink.update(uid, post_data):
                output = {
                    'addinfo ': 1,
                }
            else:
                output = {
                    'addinfo ': 0,
                }
            return json.dump(output, self)
        else:
            if MLink.update(uid, post_data):
                self.redirect('/link/list')
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
139262
def update_trackers(self):
        
        self.posts_count = self.posts.filter(approved=True).count()
        first_post = self.posts.all().order_by('created').first()
        last_post = self.posts.filter(approved=True).order_by('-created').first()
        self.first_post = first_post
        self.last_post = last_post
        self.last_post_on = last_post.created if last_post else None
        self._simple_save()
        # Trigger the forum-level trackers update
        self.forum.update_trackers()
698599
def friendship_followings(self, user_id=None, user_name=None,
                              page=1, count=20):
        
        url = 'https://openapi.youku.com/v2/users/friendship/followings.json'
        data = {
            'client_id': self.client_id,
            'page': page,
            'count': count,
            'user_id': user_id,
            'user_name': user_name
        }
        data = remove_none_value(data)
        r = requests.post(url, data=data)
        check_error(r)
        return r.json()
584654
def unfollow_user(self, user, delegate):
        
        parser = txml.Users(delegate)
        return self.__postPage('/friendships/destroy/%s.xml' % (user), parser)
588319
private void updateReplicaLayerStatusUpdateDeletion(final Node user,
			final Node statusUpdate) {
		final Node lastUpdate = NeoUtils.getNextSingleNode(user,
				SocialGraphRelationshipType.UPDATE);

		// update the ego network if the removal targets the last recent status
		// update
		if (statusUpdate.equals(lastUpdate)) {
			// get timestamp of the last recent status update in future
			long newTimestamp = 0;
			final Node nextStatusUpdate = NeoUtils.getNextSingleNode(
					statusUpdate, SocialGraphRelationshipType.UPDATE);
			if (nextStatusUpdate != null) {
				newTimestamp = (long) nextStatusUpdate
						.getProperty(Properties.StatusUpdate.TIMESTAMP);
			}

			// loop through followers
			Node replicaNode, following;
			for (Relationship replicated : user.getRelationships(
					SocialGraphRelationshipType.REPLICA, Direction.INCOMING)) {
				replicaNode = replicated.getEndNode();
				following = NeoUtils.getPrevSingleNode(replicaNode,
						SocialGraphRelationshipType.FOLLOW);

				// search for insertion index within following replica layer
				long crrTimestamp;
				Node prevReplica = following;
				Node nextReplica = null;
				while (true) {
					// get next user
					nextReplica = NeoUtils.getNextSingleNode(prevReplica,
							SocialGraphRelationshipType.GRAPHITY);
					if (nextReplica != null) {
						// ignore replica of the status update owner
						if (nextReplica.equals(replicaNode)) {
							prevReplica = nextReplica;
							continue;
						}

						crrTimestamp = getLastUpdateByReplica(nextReplica);

						// step on if current user has newer status updates
						if (crrTimestamp > newTimestamp) {
							prevReplica = nextReplica;
							continue;
						}
					}

					// insertion position has been found
					break;
				}

				// insert the replica
				if (nextReplica != null) {
					// bride the replica node
					final Node oldPrevReplica = NeoUtils.getNextSingleNode(
							replicaNode, SocialGraphRelationshipType.GRAPHITY);
					final Node oldNextReplica = NeoUtils.getNextSingleNode(
							replicaNode, SocialGraphRelationshipType.GRAPHITY);
					replicaNode.getSingleRelationship(
							SocialGraphRelationshipType.GRAPHITY,
							Direction.INCOMING).delete();

					if (oldNextReplica != null) {
						oldNextReplica.getSingleRelationship(
								SocialGraphRelationshipType.GRAPHITY,
								Direction.INCOMING).delete();
						oldPrevReplica.createRelationshipTo(oldNextReplica,
								SocialGraphRelationshipType.GRAPHITY);
					}

					// link to new neighbored nodes
					if (nextReplica != null) {
						replicaNode.createRelationshipTo(nextReplica,
								SocialGraphRelationshipType.GRAPHITY);
						prevReplica.getSingleRelationship(
								SocialGraphRelationshipType.GRAPHITY,
								Direction.OUTGOING);
					}
					prevReplica.createRelationshipTo(replicaNode,
							SocialGraphRelationshipType.GRAPHITY);
				}
			}

		}
	}
627782
def follow_user(self, user, delegate):
        
        parser = txml.Users(delegate)
        return self.__postPage('/friendships/create/%s.xml' % (user), parser)
1042403
def get_followers(self):
        
        return github.PaginatedList.PaginatedList(
            github.NamedUser.NamedUser,
            self._requester,
            "/user/followers",
            None
        )
478932
def get_user_info(twitter_user):
    
    user_info = query_user_info(user=twitter_user)
    twitter_user_data = {}
    twitter_user_data["user"] = user_info.user
    twitter_user_data["fullname"] = user_info.full_name
    twitter_user_data["location"] = user_info.location
    twitter_user_data["blog"] = user_info.blog
    twitter_user_data["date_joined"] = user_info.date_joined
    twitter_user_data["id"] = user_info.id
    twitter_user_data["num_tweets"] = user_info.tweets
    twitter_user_data["following"] = user_info.following
    twitter_user_data["followers"] = user_info.followers
    twitter_user_data["likes"] = user_info.likes
    twitter_user_data["lists"] = user_info.lists

    return twitter_user_data
604830
def delete(self, id):
        ''''''
        model = self.model.objects.only('id').get_or_404(id=id)
        follow = Follow.objects.get_or_404(follower=current_user.id,
                                           following=model,
                                           until=None)
        follow.until = datetime.now()
        follow.save()
        count = Follow.objects.followers(model).count()
        return {'followers': count}, 200
1151888
def unfollow(model)
      if self.id != model.id && self.follows?(model)

        model.before_unfollowed_by(self) if model.respond_to?('before_unfollowed_by')
        model.followers.where(:ff_type => self.class.name, :ff_id => self.id).destroy
        model.inc(:fferc, -1)
        model.after_unfollowed_by(self) if model.respond_to?('after_unfollowed_by')

        self.before_unfollow(model) if self.respond_to?('before_unfollow')
        self.followees.where(:ff_type => model.class.name, :ff_id => model.id).destroy
        self.inc(:ffeec, -1)
        self.after_unfollow(model) if self.respond_to?('after_unfollow')

      else
        return false
      end
    end
1019756
def has_in_following(self, following):
        
        assert isinstance(following, github.NamedUser.NamedUser), following
        status, headers, data = self._requester.requestJson(
            "GET",
            "/user/following/" + following._identity
        )
        return status == 204
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.')
1008561
def follow(self, author):
        ''' 
        '''
        try:
            self.steem_instance().commit.follow(author, 
                ['blog'], self.mainaccount)
        except Exception as e:
            self.msg.error_message(e)
            return False
        else:
            return True
784818
public List<User> blogFollowers(String blogName, Map<String, ?> options) {
        return requestBuilder.get(JumblrClient.blogPath(blogName, "/followers"), options).getUsers();
    }