Sets the severity_list of this Alert.

        Alert severity list for multi-threshold type.  # noqa: E501

        :param severity_list: The severity_list of this Alert.  # noqa: E501
        :type: list[str]
772749
def severity_list(self, severity_list):
        
        allowed_values = ["INFO", "SMOKE", "WARN", "SEVERE"]  # noqa: E501
        if not set(severity_list).issubset(set(allowed_values)):
            raise ValueError(
                "Invalid values for `severity_list` [{0}], must be a subset of [{1}]"  # noqa: E501
                .format(", ".join(map(str, set(severity_list) - set(allowed_values))),  # noqa: E501
                        ", ".join(map(str, allowed_values)))
            )

        self._severity_list = severity_list
994438
def p_list_type(self, p):
        ''''''
        p[0] = ast.ListType(value_type=p[3], annotations=p[5])
554216
async def on_isupport_maxlist(self, value):
        
        self._list_limits = {}

        for entry in value.split(','):
            modes, limit = entry.split(':')

            # Assign limit to mode group and add lookup entry for mode.
            self._list_limits[frozenset(modes)] = int(limit)
            for mode in modes:
                self._list_limit_groups[mode] = frozenset(modes)
51340
public void setList(List<T> list) {
        if (list != mList) {
            mList = list;
            if (mList == null) {
                notifyInvalidated();
            } else {
                notifyChanged();
            }
        }
    }
21660
def health_indicator(self, health_indicator):
        
        allowed_values = ["ok", "warning", "error"]
        if health_indicator not in allowed_values:
            raise ValueError(
                "Invalid value for `health_indicator` ({0}), must be one of {1}"
                .format(health_indicator, allowed_values)
            )

        self._health_indicator = health_indicator
237029
def _set_init_params(self, qrs_amp_recent, noise_amp_recent, rr_recent,
                         last_qrs_ind):
        
        self.qrs_amp_recent = qrs_amp_recent
        self.noise_amp_recent = noise_amp_recent
        # What happens if qrs_thr is calculated to be less than the explicit
        # min threshold? Should print warning?
        self.qrs_thr = max(0.25*self.qrs_amp_recent
                           + 0.75*self.noise_amp_recent,
                           self.qrs_thr_min * self.transform_gain)
        self.rr_recent = rr_recent
        self.last_qrs_ind = last_qrs_ind

        # No qrs detected initially
        self.last_qrs_peak_num = None
702466
def set_lane_list(self, value):
        
        if value is None or not isinstance(value, list):
            raise TypeError("LaneList new value must be a list")
        else:
            for element in value:
                if not isinstance(element, lane.Lane):
                    raise TypeError("LaneList elements in variable must be of Lane class")
            self.__lane_list = value
943543
def summary
      # Guard against the exceptions array being removed/changed or emptied here
      if exceptions.respond_to?(:first) && exceptions.first
        {
          :error_class => exceptions.first[:errorClass],
          :message => exceptions.first[:message],
          :severity => severity
        }
      else
        {
          :error_class => "Unknown",
          :severity => severity
        }
      end
    end
246455
def severity_level(self, value):
        
        if value == self._defaults['severityLevel'] and 'severityLevel' in self._values:
            del self._values['severityLevel']
        else:
            self._values['severityLevel'] = value
1262608
def change_enables(self, enables_list: list):
        
        for i, entry in enumerate(self.values):
            if enables_list[i]:
                entry.config(state=tk.NORMAL)
            else:
                entry.config(state=tk.DISABLED)
1109045
def set_completion_list(self, completion_list):
        
        self._completion_list = sorted(completion_list, key=str.lower)  # Work with a sorted list
        self._hits = []
        self._hit_index = 0
        self.position = 0
        self.bind('<KeyRelease>', self.handle_keyrelease)
78771
def set_classifier_interface_params(spec, features, class_labels,
        model_accessor_for_class_labels, output_features = None):
    
    # Normalize the features list.
    features = _fm.process_or_validate_features(features)

    if class_labels is None:
        raise ValueError("List of class labels must be provided.")

    n_classes = len(class_labels)

    output_features = _fm.process_or_validate_classifier_output_features(output_features, class_labels)

    if len(output_features) == 1:
        predicted_class_output, pred_cl_type = output_features[0]
        score_output = None
    elif len(output_features) == 2:
        predicted_class_output, pred_cl_type = output_features[0]
        score_output, score_output_type = output_features[1]
    else:
        raise ValueError("Provided output classes for a classifier must be "
                "a list of features, predicted class and (optionally) class_score.")

    spec.description.predictedFeatureName = predicted_class_output

    # Are they out of order?
    if not (pred_cl_type == datatypes.Int64() or pred_cl_type == datatypes.String()):
        raise ValueError("Provided predicted class output type not Int64 or String (%s)."
                % repr(pred_cl_type))

    if score_output is not None:
        if not isinstance(score_output_type, datatypes.Dictionary):
            raise ValueError("Provided class score output type not a Dictionary (%s)."
                    % repr(score_output_type))

        if score_output_type.key_type != pred_cl_type:
            raise ValueError(("Provided class score output (%s) key_type (%s) does not "
                    "match type of class prediction (%s).")
                    % (score_output, repr(score_output_type.key_type), repr(pred_cl_type)))

        spec.description.predictedProbabilitiesName = score_output

    # add input
    for index, (cur_input_name, input_type) in enumerate(features):
        input_ = spec.description.input.add()
        input_.name = cur_input_name
        datatypes._set_datatype(input_.type, input_type)

    # add output
    for index, (cur_output_name, output_type) in enumerate(output_features):
        output_ = spec.description.output.add()
        output_.name = cur_output_name
        datatypes._set_datatype(output_.type, output_type)

    # Worry about the class labels
    if pred_cl_type == datatypes.String():
        try:
            for c in class_labels:
                getattr(spec, model_accessor_for_class_labels).stringClassLabels.vector.append(str(c))
        # Not all the classifiers have class labels; in particular the pipeline
        # classifier.  Thus it's not an error if we can't actually set them.
        except AttributeError:
            pass

    else:
        for c in class_labels:
            conv_error = False
            try:
                if not (int(c) == c):
                    conv_error = True
            except:
                conv_error = True

            if conv_error:
                raise TypeError(("Cannot cast '%s' class to an int type " % str(c))
                + "(class type determined by type of first class).")

            try:
                getattr(spec, model_accessor_for_class_labels).int64ClassLabels.vector.append(int(c))
            # Not all the classifiers have class labels; in particular the pipeline
            # classifier.  Thus it's not an error if we can't actually set them.
            except AttributeError:
                break

    # And we are done!
    return spec
594868
public void setProvisionedCapacityList(java.util.Collection<ProvisionedCapacityDescription> provisionedCapacityList) {
        if (provisionedCapacityList == null) {
            this.provisionedCapacityList = null;
            return;
        }

        this.provisionedCapacityList = new java.util.ArrayList<ProvisionedCapacityDescription>(provisionedCapacityList);
    }
729623
def configure_warnings():
    
    if not sys.warnoptions:
        # Route warnings through python logging
        logging.captureWarnings(True)

        # DeprecationWarning is by default hidden, hence we force the
        # 'default' behavior on deprecation warnings which is not to hide
        # errors.
        warnings.simplefilter('default', DeprecationWarning)
        warnings.simplefilter('ignore', PendingDeprecationWarning)
631984
def wf_alert_severity?(severity)
      return true if %w[INFO SMOKE WARN SEVERE].include?(severity)
      raise Wavefront::Exception::InvalidAlertSeverity
    end
347635
def list_settings(self):
        
        result = super().list_settings()
        result.append((self.SETTING_TEXT_HIGHLIGHT, None))
        return result
348656
def add severity, message, context = nil, details = nil
      # Start from an empty messages list with the main message
      messages = []
      messages << sprintf(@format[:text], message) if message

      # Add raw lines
      if context.nil? && (details.is_a? Array)
        messages = details

      # Add details from array
      elsif details.is_a? Array
        details.each do |line|
          messages << sprintf(@format[:array], line)
        end 

      # Add details from hash
      elsif details.is_a?(Hash) || details.is_a?(Hashie::Mash)
        details.each do |key, value|
          messages << sprintf(@format[:hash], key, value)
        end 

      # Add each line of "details" after split
      elsif details.is_a? String
        details.lines.each do |line|
          messages << line unless line.empty?
        end 
    
      end

      # Pass all that stuff to my parent
      super severity, messages, context
    end