Add labels to this issue.

        :param str args: (required), names of the labels you wish to add
        :returns: list of :class:`Label`\ s
330767
def add_labels(self, *args):
        
        url = self._build_url('labels', base_url=self._api)
        json = self._json(self._post(url, data=args), 200)
        return [Label(l, self) for l in json] if json else []
426918
def add_arguments(self, parser):
        '''

        '''
        commands = set(name[3:] for name in dir(self) if name.startswith('do_'))
        parser.add_argument('action', help='action to run', nargs='?',
                            choices=list(commands))
        parser.add_argument('arguments', help='arguments specific to ACTION',
                            nargs=argparse.REMAINDER)
1188702
def add_messages(self, validation):
        
        if not isinstance(validation, Validation):
            raise TypeError("Argument must be of type Validation")

        self.messages.extend(validation.messages)
410441
def args_kwargs_to_initdict(args: ArgsList, kwargs: KwargsDict) -> InitDict:
    
    return {ARGS_LABEL: args,
            KWARGS_LABEL: kwargs}
765336
def __set_labels(self, labels):
        
        with self.fs.open(self.fs.join(self.path, self.LABEL_FILE), 'w') \
                as file_desc:
            for label in labels:
                file_desc.write("%s,%s\n" % (label.name,
                                             label.get_color_str()))
977885
def add_labels_to_pr(repo: GithubRepository,
                     pull_id: int,
                     *labels: str,
                     override_token: str = None) -> None:
    
    url = ("https://api.github.com/repos/{}/{}/issues/{}/labels"
           "?access_token={}".format(repo.organization,
                                     repo.name,
                                     pull_id,
                                     override_token or repo.access_token))
    response = requests.post(url, json=list(labels))

    if response.status_code != 200:
        raise RuntimeError(
            'Add labels failed. Code: {}. Content: {}.'.format(
                response.status_code, response.content))
412325
def provide_label(self):
        """"""
        return [(k, tuple([self.batch_size] + list(v.shape[1:]))) for k, v in self.label]
870220
def add_class(cls, *args):
        
        for cls2 in args:
            cls.classes[cls2.__name__] = cls2
623334
def add_arguments(cls, parser, sys_arg_list=None):
        
        parser.add_argument('--multi_plugins',
                            dest='multi_plugins', required=True,
                            help="Column seperated list of health monitor "
                                 "plugins (only for 'multi' health monitor "
                                 "plugin)")

        arglist = ["multi_plugins"]

        # Read the list of the specified sub-plugins ahead of time, so we can
        # get their classes and add their parameters.
        sub_plugin_names_str = \
                utils.param_extract(sys_arg_list, None, "--multi_plugins")
        sub_plugin_classes = \
                cls.load_sub_plugins_from_str(sub_plugin_names_str).values()

        # Store the list of the sub-plugins in the class, so we can iterate
        # over those during parameter evaluation later on.
        cls.multi_plugin_classes = sub_plugin_classes

        # Now also add the parameters for the sub-plugins
        for pc in sub_plugin_classes:
            arglist.extend(pc.add_arguments(parser, sys_arg_list))

        return arglist
1113193
def add_params(self, **kw):
        
        for k, v in kw.items():
            if k not in self.params:
                raise ValidationError(
                    '"%s" is not a valid parameter for %s'
                    % (k, self.__class__.__name__))
            self.params[k].validate(v)

        self._orig_kwargs.update(kw)
        self.kwargs = self._orig_kwargs.copy()
1035563
def get_labels(self):
        
        return github.PaginatedList.PaginatedList(
            github.Label.Label,
            self._requester,
            self.issue_url + "/labels",
            None
        )
26115
def _attach_arguments(self):
        """"""
        for arg in self.arguments:
            self.parser.add_argument(*arg[0], **arg[1])
1347618
def _additional(self, idents, kwargs):
        ''''''
        if kwargs:
            for name, value in list(kwargs.items()):
                if not isinstance(value, list):
                    raise ValueError('Additional arguments must be lists of \
same length as idents')
                for i in range(len(value)):
                    self[idents[i]][name] = value[i]
298472
def __learn_labels(self, labels):
        
        if self.feature_length > 0:
            result = list(self.labels.classes_)
        else:
            result = []

        for label in labels:
            result.append(label)
        self.labels.fit(result)
647097
def add_label(self, name, color):
        """"""
        color_upper = color.upper()
        if not self._color_re.match(color_upper):
            raise ValueError('Invalid color: {}'.format(color))

        labels_tag = self.root[0]
        last_id = int(labels_tag[-1].get('id'))
        new_id = str(last_id + 1)

        new_label = etree.Element('label', id=new_id, color=color_upper)
        new_label.text = name

        labels_tag.append(new_label)
126916
def add(self, response, label=None):
        
        if not isinstance(response, sip_response.sip_response):
            raise Exception(
                'can only add sip_reponse.sip_response objects'
            )
        self.objects.append(response)

        if label is None:
            self.labels.append('na')
        else:
            self.labels.append(label)
903295
def _latex_labels(self, labels):
        

        config = self._configuration.get("latex_labels", {})
        return [config.get(label, label) for label in labels]