:calls: `DELETE /repos/:owner/:repo/pulls/:number/requested_reviewers <https://developer.github.com/v3/pulls/review_requests/>`_
        :param reviewers: list of strings
        :param team_reviewers: list of strings
        :rtype: None
353680
def delete_review_request(self, reviewers=github.GithubObject.NotSet, team_reviewers=github.GithubObject.NotSet):
        
        post_parameters = dict()
        if reviewers is not github.GithubObject.NotSet:
            assert all(isinstance(element, (str, unicode)) for element in reviewers), reviewers
            post_parameters["reviewers"] = reviewers
        if team_reviewers is not github.GithubObject.NotSet:
            assert all(isinstance(element, (str, unicode)) for element in team_reviewers), team_reviewers
            post_parameters["team_reviewers"] = team_reviewers
        headers, data = self._requester.requestJsonAndCheck(
            "DELETE",
            self.url + "/requested_reviewers",
            input=post_parameters
        )
327243
def post_pr_comment(self, patch):
        
        if self.has_violations:
            post_pr_comment = True

            # Attempt to post a PR review. If posting the PR review fails because the bot account
            # does not have permission to review the PR then simply revert to posting a regular PR
            # comment.
            try:
                logger.info('Deleting old PR review comments')
                self.git_client.delete_pull_request_review_comments(self.config.pr)

                logger.info('Creating PR review')
                self.git_client.create_pull_request_review(self.config.pr, patch, self._diff_violations)
                post_pr_comment = False
            except GitClientError as e:
                # TODO: Make `create_pull_request_review` raise an `UnauthorizedError`
                # so that we don't have to check for a specific message in the exception
                if 'Viewer does not have permission to review this pull request' in str(e):
                    logger.warning("Could not post PR review (the account didn't have permission)")
                    pass
                else:
                    raise

            if post_pr_comment:
                logger.info('Deleting old PR comment')
                self.git_client.delete_pull_request_comments(self.config.pr)

                logger.info('Creating PR comment')
                comment = build_pr_comment(self.config, self.violations)
                self.git_client.create_pull_request_comment(self.config.pr, comment)
1033706
def delete(self, comment_id, issue_id=None, repo_slug=None):
        
        issue_id = issue_id or self.issue_id
        repo_slug = repo_slug or self.bitbucket.repo_slug or ''
        url = self.bitbucket.url('DELETE_COMMENT',
                                 username=self.bitbucket.username,
                                 repo_slug=repo_slug,
                                 issue_id=issue_id,
                                 comment_id=comment_id)
        return self.bitbucket.dispatch('DELETE', url, auth=self.bitbucket.auth)
516994
def remove_label_from_pr(repo: GithubRepository,
                         pull_id: int,
                         label: str) -> bool:
    
    url = ("https://api.github.com/repos/{}/{}/issues/{}/labels/{}"
           "?access_token={}".format(repo.organization,
                                     repo.name,
                                     pull_id,
                                     label,
                                     repo.access_token))
    response = requests.delete(url)

    if response.status_code == 404:
        payload = json.JSONDecoder().decode(response.content.decode())
        if payload['message'] == 'Label does not exist':
            return False

    if response.status_code == 200:
        # Removed the label.
        return True

    raise RuntimeError(
        'Label remove failed. Code: {}. Content: {}.'.format(
            response.status_code, response.content))
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}.`)
  }
}
113125
def delete_GitHub_token(token_id, *, auth, headers):
    """"""
    r = requests.delete('https://api.github.com/authorizations/{id}'.format(id=token_id), auth=auth, headers=headers)
    GitHub_raise_for_status(r)
151440
def delete(self, *args, **kwargs):
        """"""
        # XXX: circular import
        from fields import RatingField

        qs = self.distinct().values_list('content_type', 'object_id').order_by('content_type')
    
        to_update = []
        for content_type, objects in itertools.groupby(qs, key=lambda x: x[0]):
            model_class = ContentType.objects.get(pk=content_type).model_class()
            if model_class:
                to_update.extend(list(model_class.objects.filter(pk__in=list(objects)[0])))
        
        retval = super(VoteQuerySet, self).delete(*args, **kwargs)
        
        # TODO: this could be improved
        for obj in to_update:
            for field in getattr(obj, '_djangoratings', []):
                getattr(obj, field.name)._update(commit=False)
            obj.save()
        
        return retval
856360
def delete_commit(self, commit):
        
        req = proto.DeleteCommitRequest(commit=commit_from(commit))
        self.stub.DeleteCommit(req, metadata=self.metadata)
2560
def clean_remotes
      protected_remotes = remotes_for_branches
      remotes.each do |remote|
        # Only remove review remotes that aren't referenced by current branches.
        if remote.index('review_') == 0 && !protected_remotes.include?(remote)
          git_call "remote remove #{remote}"
        end
      end
    end
746830
def summary(self):
        
        if self._summary:
            return self._summary

        reviewers = self._graph.retrieve_reviewers(self)
        return self._summary_cls(
            [self._graph.retrieve_review(r, self) for r in reviewers])
257934
def get_required_pull_request_reviews(self):
        
        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self.protection_url + "/required_pull_request_reviews",
            headers={'Accept': Consts.mediaTypeRequireMultipleApprovingReviews}
        )
        return github.RequiredPullRequestReviews.RequiredPullRequestReviews(self._requester, headers, data, completed=True)
701123
def mail(ui, repo, *pats, **opts):
	
	if codereview_disabled:
		raise hg_util.Abort(codereview_disabled)

	cl, err = CommandLineCL(ui, repo, pats, opts, op="mail", defaultcc=defaultcc)
	if err != "":
		raise hg_util.Abort(err)
	cl.Upload(ui, repo, gofmt_just_warn=True)
	if not cl.reviewer:
		# If no reviewer is listed, assign the review to defaultcc.
		# This makes sure that it appears in the 
		# codereview.appspot.com/user/defaultcc
		# page, so that it doesn't get dropped on the floor.
		if not defaultcc:
			raise hg_util.Abort("no reviewers listed in CL")
		cl.cc = Sub(cl.cc, defaultcc)
		cl.reviewer = defaultcc
		cl.Flush(ui, repo)

	if cl.files == []:
			raise hg_util.Abort("no changed files, not sending mail")

	cl.Mail(ui, repo)
170559
def reviews(params = {})
      data = request("/review/list", params.merge(v: "2"))
      reviews = data["reviews"]["review"]
      if reviews.present?
        reviews.map { |review| Hashie::Mash.new(review) }
      else
        []
      end
    end
823646
def delete(package):
    
    team, owner, pkg = parse_package(package)

    answer = input(
        "Are you sure you want to delete this package and its entire history? "
        "Type '%s' to confirm: " % package
    )

    if answer != package:
        print("Not deleting.")
        return 1

    session = _get_session(team)

    session.delete("%s/api/package/%s/%s/" % (get_registry_url(team), owner, pkg))
    print("Deleted.")
1072322
def delete(name)
      begin
        github.api.delete_label!(repo, name)
      rescue Octokit::Error => e
        puts "Error message: \"#{name}\" label is not existing."
        puts e
      end
    end
1199104
def destroy(self, request, project, pk=None):
        
        job_id, bug_id = map(int, pk.split("-"))
        job = Job.objects.get(repository__name=project, id=job_id)
        BugJobMap.objects.filter(job=job, bug_id=bug_id).delete()

        return Response({"message": "Bug job map deleted"})
920815
private function removeReviewsAndExtractSubject(ReviewInterface $review, array $reviewSubjectsToRecalculate): array
    {
        $reviewSubject = $review->getReviewSubject();

        if (!in_array($reviewSubject, $reviewSubjectsToRecalculate)) {
            $reviewSubjectsToRecalculate[] = $reviewSubject;
        }

        $this->reviewManager->remove($review);

        return $reviewSubjectsToRecalculate;
    }