Removes given **Active_QLabel** Widget.

        :param active_label: Active label to remove.
        :type active_label: Active_QLabel
        :return: Method success.
        :rtype: bool
6347
def remove_active_label(self, active_label):
        

        if not active_label in self.__active_labels:
            raise foundations.exceptions.ProgrammingError("{0} | '{1}' is not in the collection!".format(
                self.__class__.__name__, active_label))

        self.__active_labels.remove(active_label)
        return True
270518
def RemoveClientLabels(self, client, labels_names):
    """"""

    affected_owners = set()
    for label in client.GetLabels():
      if label.name in labels_names and label.owner != "GRR":
        affected_owners.add(label.owner)

    for owner in affected_owners:
      client.RemoveLabels(labels_names, owner=owner)
840629
def remove_label(self, to_remove):
        
        if to_remove not in self.labels:
            return
        labels = self.labels
        labels.remove(to_remove)
        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()))
1092019
def strip_label(mapper, connection, target):
    """"""
    if target.label is not None:
        target.label = target.label.strip()
37994
def RemoveClientLabels(self, client_id, owner, labels):
    """"""
    labelset = self.labels.setdefault(client_id, {}).setdefault(owner, set())
    for l in labels:
      labelset.discard(utils.SmartUnicode(l))
194733
def remove_widget(self):
        

        LOGGER.debug("> Removing '{0}' Component Widget.".format(self.__class__.__name__))

        self.__preferences_manager.findChild(QGridLayout, "Others_Preferences_gridLayout").removeWidget(self)
        self.TCP_Client_Ui_groupBox.setParent(None)

        return True
333110
def stop(self):
        
        if not self.active:
            return
        self.removeHandler(self.handlers[-1])
        self.active = False
        return
7758
public MonitorService deleteLabel(String monitorId, Label label)
    {
        HTTP.DELETE(String.format("/v1/monitors/%s/labels/%s", monitorId, label.getKey()));
        return this;
    }
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()
879626
def qteAutoremoveDeletedWidgets(self):
        
        widget_list = self._qteAdmin.widgetList
        deleted_widgets = [_ for _ in widget_list if sip.isdeleted(_)]
        for widgetObj in deleted_widgets:
            self._qteAdmin.widgetList.remove(widgetObj)
442445
def truncate_label(cls, label):
        
        label = hashlib.md5(label.encode('utf-8')).hexdigest()
        # truncate hash if it exceeds max length
        if cls.max_column_name_length and len(label) > cls.max_column_name_length:
            label = label[:cls.max_column_name_length]
        return label
1290374
def del_stream(self, bucket, label):
        
        bucket = self._require_bucket(bucket)
        key = self._require_key(bucket, label)
        key.delete()
244889
def del_label(self, name):
        """"""
        labels_tag = self.root[0]
        labels_tag.remove(self._find_label(name))
710630
function exitLabeledScope(node) {
            if (!scopeInfo.used) {
                context.report({
                    node: node.label,
                    messageId: "unused",
                    data: node.label,
                    fix(fixer) {

                        /*
                         * Only perform a fix if there are no comments between the label and the body. This will be the case
                         * when there is exactly one token/comment (the ":") between the label and the body.
                         */
                        if (sourceCode.getTokenAfter(node.label, { includeComments: true }) ===
                                sourceCode.getTokenBefore(node.body, { includeComments: true })) {
                            return fixer.removeRange([node.range[0], node.body.range[0]]);
                        }

                        return null;
                    }
                });
            }

            scopeInfo = scopeInfo.upper;
        }
1274369
def destroy
      unless widget.present? && widget.destroy
        return render json: { errors: 'Cannot delete widget' }, status: :bad_request
      end

      MnoEnterprise::EventLogger.info('widget_delete', current_user.id, "#{container} Widget Deletion", widget)
      head status: :ok
    end
505798
def label(self, label, action='ADD', params=None):
        

        if params is None:
            params = {}

        if not label:
            self._tcex.handle_error(925, ['label', 'Security Label', 'label', 'label', label])

        if not self.can_update():
            self._tcex.handle_error(910, [self.type])

        if action == 'GET':
            return self.tc_requests.get_label(
                self.api_type,
                self.api_sub_type,
                self.unique_id,
                label,
                owner=self.owner,
                params=params,
            )

        if action == 'ADD':
            return self.tc_requests.add_label(
                self.api_type, self.api_sub_type, self.unique_id, label, owner=self.owner
            )

        if action == 'DELETE':
            return self.tc_requests.delete_label(
                self.api_type, self.api_sub_type, self.unique_id, label, owner=self.owner
            )

        self._tcex.handle_error(925, ['action', 'label', 'action', 'action', action])
        return None
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)