:calls: `DELETE /user/subscriptions/:owner/:repo <http://developer.github.com/v3/activity/watching>`_
        :param subscription: :class:`github.Repository.Repository`
        :rtype: None
971985
def remove_from_subscriptions(self, subscription):
        
        assert isinstance(subscription, github.Repository.Repository), subscription
        headers, data = self._requester.requestJsonAndCheck(
            "DELETE",
            "/user/subscriptions/" + subscription._identity
        )
225189
public static void removeSubscription(Subscription subscription) {
        mSubscriptions.remove(subscription);
        LiveQueryClient.executeQuery(subscription.getQuery().unsubscribeQueryToString());
    }
1277908
def remove_user(self, user):
        
        org_user = self._org_user_model.objects.get(user=user, organization=self)
        org_user.delete()

        # User removed signal
        user_removed.send(sender=self, user=user)
686700
function removeSubscriber (args, token) {
    var
      topics = args.topics,
      suspendSubs = args.suspend;

    if (typeof token === 'string') {
      return !!applyTopicDescendents(
        suspendSubs ? suspendTopic : empty, 'subscriptions', token, topics
      );
    }

    var node = ancestorTopicSearch(token.topic, topics);
    if (node.topic !== token.topic) {
      return false;
    }

    var i = searchAround(
      getId, getPriority,
      token.id, token.priority,
      binaryIndexBy(getPriority, token.priority, node.subscriptions),
      node.subscriptions
    );

    if (i === -1) {
      return false;
    }

    if (suspendSubs) {
      return !!suspendNode(node.subscriptions[i]);
    }

    return !!node.subscriptions.splice(i, 1);
  }
600119
def delete(self, main_type, sub_type, unique_id, owner=None):
        
        params = {'owner': owner} if owner else {}
        if not sub_type:
            url = '/v2/{}/{}'.format(main_type, unique_id)
        else:
            url = '/v2/{}/{}/{}'.format(main_type, sub_type, unique_id)
        return self.tcex.session.delete(url, params=params)
245998
def delete_subscription(self, subscription_id):
        
        self._validate_uuid(subscription_id)

        url = "/notification/v1/subscription/{}".format(subscription_id)
        response = NWS_DAO().deleteURL(url, self._write_headers())

        if response.status != 204:
            raise DataFailureException(url, response.status, response.data)

        return response.status
1035154
def add_to_watched(self, watched):
        
        assert isinstance(watched, github.Repository.Repository), watched
        headers, data = self._requester.requestJsonAndCheck(
            "PUT",
            "/repos/" + watched._identity + "/subscription",
            input={"subscribed": True}
        )
1128493
def delete(self, request, **kwargs):
		
		try:
			customer, _created = Customer.get_or_create(
				subscriber=subscriber_request_callback(self.request)
			)
			customer.subscription.cancel(at_period_end=CANCELLATION_AT_PERIOD_END)

			return Response(status=status.HTTP_204_NO_CONTENT)
		except Exception:
			return Response(
				"Something went wrong cancelling the subscription.",
				status=status.HTTP_400_BAD_REQUEST,
			)
411869
def remove_subscriber(self, message):
        
        logger.debug("Remove Subcriber")
        host, port = message.destination
        key_token = hash(str(host) + str(port) + str(message.token))
        try:
            self._relations[key_token].transaction.completed = True
            del self._relations[key_token]
        except KeyError:
            logger.warning("No Subscriber")
474691
def delete_resource_group(access_token, subscription_id, rgname):
    '''
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/resourcegroups/', rgname,
                        '?api-version=', RESOURCE_API])
    return do_delete(endpoint, access_token)
141467
def delete_subscription(self, subscription_id):
        
        url = self.SUBSCRIPTIONS_ID_URL % subscription_id

        connection = Connection(self.token)
        connection.set_url(self.production, url)

        return connection.delete_request()
666108
def remove(self, parameters):
        

        # Verify that we already know our assigned subscription_id
        assert self.subscription_id != -1

        if not parameters:
            return

        options = web_pb2.ParameterSubscriptionRequest()
        options.subscriptionId = self.subscription_id
        options.id.extend(_build_named_object_ids(parameters))

        self._manager.send('unsubscribe', options)
947838
def remove_outside_collaborator(self, collaborator):
        
        assert isinstance(collaborator, github.NamedUser.NamedUser), collaborator
        headers, data = self._requester.requestJsonAndCheck(
            "DELETE",
            self.url + "/outside_collaborators/" + collaborator._identity
        )
546692
async function del(owner, repo) {
  const endpoint = `/user/starred/${owner}/${repo}`
  const { statusCode } = await this._request({
    method: 'PUT',
    data: {},
    endpoint,
  })
  if (statusCode != 204) {
    throw new Error(`Unexpected status code ${statusCode}.`)
  }
}
293707
def delete_subscriptions(self):
        
        warnings.warn('This could be slow for large numbers of connected devices.'
                      'If possible, explicitly delete subscriptions known to have been created.')
        for device in self.list_connected_devices():
            try:
                self.delete_device_subscriptions(device_id=device.id)
            except CloudApiException as e:
                LOG.warning('failed to remove subscription for %s: %s', device.id, e)
                continue
1255562
def remove(self):
        
        self.logger.debug('Remove subscription from server...')

        data = {
            'command': 'unsubscribe',
            'identifier': self._identifier_string()
        }

        self.connection.send(data)
        self.state = 'unsubscribed'
261677
def delete(*args)
      arguments(args, required: [:user, :repo, :ref])
      params = arguments.params

      delete_request("/repos/#{arguments.user}/#{arguments.repo}/git/refs/#{arguments.ref}", params)
    end