Unpin / un-endorse a user.

        Returns a `relationship dict`_ containing the updated relationship to the user.
777723
def account_unpin(self, id):
        
        id = self.__unpack_id(id)
        url = '/api/v1/accounts/{0}/unpin'.format(str(id))
        return self.__api_request('POST', url)
68545
def unfollow(self, target_id):
        
        if self.id is None:
            raise ValueError('Please sign in')
        response = client.delete('/users/{0}/friendship/{1}'.format(self.id, target_id), None)
        assert response.ok
683131
def delete_user(self, user):
        
        name = utils.get_name(user)
        self._user_manager.delete(name)
393212
def remove_role_from_user(self, user, role):
        
        rv = False
        user, role = self._prepare_role_modify_args(user, role)
        if role in user.roles:
            rv = True
            user.roles.remove(role)
            self.put(user)
        return rv
177281
def account_unfollow(self, id):
        
        id = self.__unpack_id(id)
        url = '/api/v1/accounts/{0}/unfollow'.format(str(id))
        return self.__api_request('POST', url)
842941
def unfollow(user, obj):
    
    try:
        follow = Follow.objects.get_follows(obj).get(user=user)
        follow.delete()
        return follow 
    except Follow.DoesNotExist:
        pass
420381
def revert(candidate_id, member_id)
      post_request("candidates/#{candidate_id}/revert") do |request|
        request.body = { member_id: member_id }.to_json
      end
    end
360386
def unsubscribe(self, request, *args, **kwargs):
        
        self.object = self.get_object()
        self.object.subscribers.remove(request.user)
        messages.success(self.request, self.success_message)
        return HttpResponseRedirect(self.get_success_url())
879676
def remove_user(user):
    """"""
    def processor(action, argument):
        ActionUsers.query_by_action(action, argument=argument).filter(
            ActionUsers.user_id == user.id
        ).delete(synchronize_session=False)
    return processor
1168573
def unregister(self, model=None):
        ''''''
        if model is not None:
            try:
                manager = self._registered_models.pop(model)
            except KeyError:
                return
            if self._registered_names.get(manager._meta.name) == manager:
                self._registered_names.pop(manager._meta.name)
            return [manager]
        else:
            managers = list(self._registered_models.values())
            self._registered_models.clear()
            return managers
833082
def unsubscribe_from_human_connection_events(
        self,
        subscriber: Callable[[events.HumanConnectionEvent], None],
    ) -> None:
        
        self._human_connection_subscribers.remove(subscriber)
459736
def unban_user(self, room_id, user_id):
        
        body = {
            "user_id": user_id
        }
        return self._send("POST", "/rooms/" + room_id + "/unban", body)
591866
def unlink(self, req, parent, name):
        
        self.reply_err(req, errno.EROFS)
1219170
def _modify_relationship(relationship, unlink=False, is_sub=False):
    
    # The API uses friend and unfriend to manage all of these relationships.
    url_key = 'unfriend' if unlink else 'friend'

    if relationship == 'friend':
        access = {'scope': None, 'login': True}
    elif relationship == 'moderator':
        access = {'scope': 'modothers'}
    elif relationship in ['banned', 'contributor', 'muted']:
        access = {'scope': 'modcontributors'}
    elif relationship in ['wikibanned', 'wikicontributor']:
        access = {'scope': ['modcontributors', 'modwiki']}
    else:
        access = {'scope': None, 'mod': True}

    @restrict_access(**access)
    def do_relationship(thing, user, **kwargs):
        data = {'name': six.text_type(user),
                'type': relationship}
        data.update(kwargs)
        if is_sub:
            data['r'] = six.text_type(thing)
        else:
            data['container'] = thing.fullname

        session = thing.reddit_session
        if relationship == 'moderator':
            session.evict(session.config['moderators'].format(
                subreddit=six.text_type(thing)))
        url = session.config[url_key]
        return session.request_json(url, data=data)
    return do_relationship
990722
def delete_user(self, user_id, **kwargs):
        
        return DeleteUser(settings=self.settings, **kwargs).call(user_id=user_id, **kwargs)
409981
def revoke_user_token(self, user_id):
        
        user = self.get(user_id)
        user._token = None
        self.save(user)
286380
public void deleteUser(final Node user) {
		Node userReplica, following;
		for (Relationship replica : user.getRelationships(
				SocialGraphRelationshipType.REPLICA, Direction.INCOMING)) {
			userReplica = replica.getEndNode();
			following = NeoUtils.getPrevSingleNode(userReplica,
					SocialGraphRelationshipType.FOLLOW);
			this.removeFriendship(following, user);
		}
	}