Remove the time series for specific label values.

        :type label_values: list(:class:`LabelValue`)
        :param label_values: Label values of the time series to remove.
160229
def remove_time_series(self, label_values):
        
        if label_values is None:
            raise ValueError
        if any(lv is None for lv in label_values):
            raise ValueError
        if len(label_values) != self._len_label_keys:
            raise ValueError
        self._remove_time_series(label_values)
22397
def remove_sites_from_neighbours( self, remove_labels ):
        
        if type( remove_labels ) is str:
            remove_labels = [ remove_labels ]
        self.neighbours = set( n for n in self.neighbours if n.label not in remove_labels )
718499
def wrap(self, values):
        
        if isinstance(values, Value):
            return values
        cols = dict([(L, []) for L in self.labels])
        try:
            # unzip list of dict
            for V in values:
                for L in self.labels:
                    try:
                        cols[L].append(V[L])
                    except (IndexError, KeyError):
                        pass
            # allow omit empty columns
            for L in self.labels:
                V = cols[L]
                if len(V) == 0:
                    del cols[L]

            try:
                return self.Value(self.type, {
                    'labels': self.labels,
                    'value': cols,
                })
            except:
                _log.error("Failed to encode '%s' with %s", cols, self.labels)
                raise
        except:
            _log.exception("Failed to wrap: %s", values)
            raise
726590
function(value)
	{
		this._removeAxisFunctions(this._xAxisLabelFunctions);
		var len = value.length;
		for(var i = 0; i < len; i++)
		{
			if(value[i].position == "left") value[i].position = "bottom";
			value[i] = this._getClonedAxis(value[i]);
			if(value[i].labelFunction) this._xAxisLabelFunctions.push(value[i].labelFunction);
			this._swf.setHorizontalAxis(value[i]);
		}
	}
1271172
def remove_labels(self):
        ''''''
        for rep_id in self.representations.keys():
            if self.representations[rep_id]['rep_type']=='text' and rep_id not in self._axes_reps:
                self.remove_representation(rep_id)
801304
def time_report_item(self, label, message=None):
        
        next_ = TIMESTAMPS_ORDER[TIMESTAMPS_ORDER.index(label) + 1]
        while next_ not in self._timestamps:
            next_ = TIMESTAMPS_ORDER[TIMESTAMPS_ORDER.index(next_) + 1]

        assert label in TIMESTAMPS_ORDER
        start = self._timestamps[label] - self._timestamps[TIMESTAMPS_ORDER[0]]
        end = self._timestamps[next_] - self._timestamps[TIMESTAMPS_ORDER[0]]
        return {'Message': message,
                'Start': start,
                'End': end,
                'Sum': end - start,
                'Count': 1}
809470
def remove_label(self, name):
        
        url = self._build_url('labels', name, base_url=self._api)
        # Docs say it should be a list of strings returned, practice says it
        # is just a 204/404 response. I'm tenatively changing this until I
        # hear back from Support.
        return self._boolean(self._delete(url), 204, 404)
943359
def RemoveLabels(self, labels_names, owner=None):
    """"""
    if owner is None and not self.token:
      raise ValueError("Can't remove label: No owner specified and "
                       "no access token available.")
    if isinstance(labels_names, string_types):
      raise ValueError("Label list can't be string.")

    owner = owner or self.token.username

    current_labels = self.Get(self.Schema.LABELS)
    for label_name in labels_names:
      label = rdf_aff4.AFF4ObjectLabel(name=label_name, owner=owner)
      current_labels.RemoveLabel(label)

    self.Set(self.Schema.LABELS, current_labels)
551512
def value_labels(self):
        

        from operator import itemgetter

        card = self.pstats.nuniques

        if self.label:
            ig = itemgetter(self.name, self.label.name)
        elif self.pstats.nuniques < MAX_LABELS:
            ig = itemgetter(self.name, self.name)
        else:
            return {}

        label_set = set()
        for row in self._partition:
            label_set.add(ig(row))

            if len(label_set) >= card:
                break

        d = dict(label_set)

        assert len(d) == len(label_set)  # Else the label set has multiple values per key

        return d
1268256
def clean(self):
        
        for key, value in self.values.copy().items():
            if value is None:
                del self.values[key]
861532
def set_value(self, labels, value):
        

        if labels:
            self._label_names_correct(labels)

        with mutex:
            self.values[labels] = value
40941
def _remove_list_item(self, beacon_config, label):
        '''
        
        '''

        index = self._get_index(beacon_config, label)
        del beacon_config[index]
1339489
def remove_label(self, label):
        
        self._logger.info('Removing label "{}"'.format(label))
        count = self._matches[constants.LABEL_FIELDNAME].value_counts().get(
            label, 0)
        self._matches = self._matches[
            self._matches[constants.LABEL_FIELDNAME] != label]
        self._logger.info('Removed {} labelled results'.format(count))
666616
protected void processLabels(List<MonolingualTextValue> labels) {
        for(MonolingualTextValue label : labels) {
        	String lang = label.getLanguageCode();
        	NameWithUpdate currentValue = newLabels.get(lang);
        	if (currentValue == null || !currentValue.value.equals(label)) {
	            newLabels.put(lang,
	                    new NameWithUpdate(label, true));
	            
	            // Delete any alias that matches the new label
	            AliasesWithUpdate currentAliases = newAliases.get(lang);
	            if (currentAliases != null && currentAliases.aliases.contains(label)) {
	            	deleteAlias(label);
	            }
        	}
        }
        
    }
1366440
def clean(self, value):
        
        value = super().clean(value)
        if value in (None, ''):
            value = ''
        value = smart_text(value)
        if value == '':
            return value
        valid_values = []
        for group_label, group in self.choices:
            valid_values += [str(k) for k, v in group]
        if value not in valid_values:
            raise ValidationError(gettext('Select a valid choice. That choice is not one of the available choices.'))
        return value
235334
def stop(label, at=None, remove_from_labels=False, stop_once=True):
    """"""
    t = at if at is not None else time.time()

    if label not in labels:
        return None

    timer = Marker().loads(labels[label])

    if timer.is_running() or (timer.is_stopped() and not stop_once):
        timer.stop(t)

    if remove_from_labels:
        del labels[label]
    else:
        labels[label] = timer.dumps()

    return timer.duration()
249743
def deletelabel(self, project_id, name):
        
        data = {'name': name}

        request = requests.delete(
            '{0}/{1}/labels'.format(self.projects_url, project_id), data=data,
            verify=self.verify_ssl, auth=self.auth, headers=self.headers, timeout=self.timeout)

        return request.status_code == 200