References:
        https://developer.github.com/v3/issues/labels/#remove-a-label-from-an-issue
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))
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
939418
def node_label_folder_absent(name, node, **kwargs):
    '''
    
    '''

    ret = {'name': name,
           'changes': {},
           'result': False,
           'comment': ''}
    labels = __salt__['kubernetes.node_labels'](node, **kwargs)

    folder = name.strip("/") + "/"
    labels_to_drop = []
    new_labels = []
    for label in labels:
        if label.startswith(folder):
            labels_to_drop.append(label)
        else:
            new_labels.append(label)

    if not labels_to_drop:
        ret['result'] = True if not __opts__['test'] else None
        ret['comment'] = 'The label folder does not exist'
        return ret

    if __opts__['test']:
        ret['comment'] = 'The label folder is going to be deleted'
        ret['result'] = None
        return ret

    for label in labels_to_drop:
        __salt__['kubernetes.node_remove_label'](
            node_name=node,
            label_name=label,
            **kwargs)

    ret['result'] = True
    ret['changes'] = {
        'kubernetes.node_label_folder_absent': {
            'old': list(labels),
            'new': new_labels,
        }
    }
    ret['comment'] = 'Label folder removed from node'

    return ret
576473
def remove_label(self, doc, label, update_index=True):
        
        doc.remove_label(label)
        if update_index:
            self.upd_doc(doc)
            self.commit()
1254265
def remove(name)
      begin
        github.api.remove_label(repo, number, name)
      rescue Octokit::Error => e
        puts "Error message: \"#{name}\" label is not existing."
        puts e
      end
    end
1344097
def exclude_issues_by_labels(issues)
      return issues if !options[:exclude_labels] || options[:exclude_labels].empty?

      issues.reject do |issue|
        labels = issue["labels"].map { |l| l["name"] }
        (labels & options[:exclude_labels]).any?
      end
    end
1245997
def RemoveClientLabels(self, client_id, owner, labels, cursor=None):
    """"""

    query = ("DELETE FROM client_labels "
             "WHERE client_id = %s AND owner_username_hash = %s "
             "AND label IN ({})").format(", ".join(["%s"] * len(labels)))
    args = [db_utils.ClientIDToInt(client_id), mysql_utils.Hash(owner)] + labels
    cursor.execute(query, args)
1333143
def Handle_Delete_Label(self, msg):
        

        try:
            label_name = msg['object']['label']
        except KeyError:
            r_msg = {'status': 'ERROR',
                     'type': 'Delete_Label',
                     'object': {'msg': 'improper request'}}
            return json.dumps(r_msg)
        else:
            r_val = {'status': 'OK',
                     'type': 'Delete',
                     'object': self.db.deleteLabel(label_name)}
            return json.dumps(r_val)
434598
public function remove($username, $repository, $issue, $label)
    {
        return $this->delete('/repos/'.rawurlencode($username).'/'.rawurlencode($repository).'/issues/'.rawurlencode($issue).'/labels/'.rawurlencode($label));
    }
11500
def RemoveClientLabels(self, client_id, labels):
    
    for label in labels:
      keyword = self._NormalizeKeyword(label)
      # This might actually delete a keyword with the same name as the label (if
      # there is one).
      data_store.REL_DB.RemoveClientKeyword(client_id, keyword)
      data_store.REL_DB.RemoveClientKeyword(client_id, "label:%s" % keyword)
541873
def remove(pkg):
    '''
    
    '''
    ret = {'result': None, 'output': ""}
    try:
        ret['output'] = subprocess.check_output([SNAP_BINARY_NAME, 'remove', pkg])
        ret['result'] = True
    except subprocess.CalledProcessError as e:
        ret['output'] = e.output
        ret['result'] = False
901674
def forget(self, label_name):
        
        self._bayes.pop(label_name)
        baye_dir = self._get_baye_dir(label_name)
        logger.info("Deleting label training {} : {}".format(
            label_name, baye_dir
        ))
        rm_rf(baye_dir)
562903
def edit(self, name, label=None):
        
        if not name:
            return False
        edit_data = {'name': name, 'label': label}
        self._remove_none(edit_data)
        r = self._patch(
            self._api,
            data=json.dumps(edit_data),
            headers=Release.CUSTOM_HEADERS
        )
        successful = self._boolean(r, 200, 404)
        if successful:
            self.__init__(r.json(), self)

        return successful
1121403
def remove_label(self, label):
        
        works_to_delete = []
        for work, work_label in self.items():
            if work_label == label:
                works_to_delete.append(work)
        for work in works_to_delete:
            del self[work]
        if self._ordered_labels:
            self._ordered_labels.remove(label)
1166192
function reportIfUnnecessary(node) {
            if (!node.label) {
                return;
            }

            const labelNode = node.label;

            for (let info = scopeInfo; info !== null; info = info.upper) {
                if (info.breakable || info.label && info.label.name === labelNode.name) {
                    if (info.breakable && info.label && info.label.name === labelNode.name) {
                        context.report({
                            node: labelNode,
                            messageId: "unexpected",
                            data: labelNode,
                            fix: fixer => fixer.removeRange([sourceCode.getFirstToken(node).range[1], labelNode.range[1]])
                        });
                    }
                    return;
                }
            }
        }
1093682
def _remove_references(self, removed_part):
        
        removed_part.parent = None

        # Remove labels in the hierarchy pointing to this part.
        referrers_to_remove = set()
        for referrer in removed_part.referrers:
            if removed_part not in referrer.ancestors():
                for label, referred_part in list(referrer.labels.items()):
                    if referred_part is removed_part:
                        del referrer.labels[label]
                        referrers_to_remove.add(referrer)
        removed_part.referrers -= referrers_to_remove

        # Remove labels in this part pointing into the hierarchy.
        labels_to_delete = []
        if isinstance(removed_part, Compound):
            for label, part in list(removed_part.labels.items()):
                if not isinstance(part, Compound):
                    for p in part:
                        self._remove_references(p)
                elif removed_part not in part.ancestors():
                    try:
                        part.referrers.discard(removed_part)
                    except KeyError:
                        pass
                    else:
                        labels_to_delete.append(label)
        for label in labels_to_delete:
            removed_part.labels.pop(label, None)
518402
def wip=(pr)
      label_names = []
      labels.each do |label|
        label_names << label.name
      end
      puts("exist labels:" + label_names.join(", "))
      unless wip?
        begin
          add_label("WIP")
        rescue Octokit::UnprocessableEntity => e
          puts "WIP label is already exists."
          puts e
        end
      end
      github.api.add_labels_to_an_issue(repo, pr, [wip_label])
    end