Deprecated -- do not use this constructor directly. Use the model-
        specific constructors available in this module.
348129
def Pipette(self, *args, **kwargs):
        
        return inst.Pipette(self.robot, *args, **kwargs)
173080
def use_model(self, model_name):
        
        # Check against exclude list.
        if self.exclude_models:
            for model_pattern in self.exclude_models:
                model_pattern = '^%s$' % model_pattern.replace('*', '.*')
                if re.search(model_pattern, model_name):
                    return False
        # Check against exclude list.
        elif self.include_models:
            for model_pattern in self.include_models:
                model_pattern = '^%s$' % model_pattern.replace('*', '.*')
                if re.search(model_pattern, model_name):
                    return True
        # Return `True` if `include_models` is falsey, otherwise return `False`.
        return not self.include_models
408559
def include_constructor(self, loader, node):
        
        v = self._unfold_yaml(node.value)

        return v
412257
def deprecated(message, stacklevel=2):  # pragma: no cover
    

    def _decorator(func):
        @wraps(func)
        def _func(*args, **kwargs):
            warnings.warn(
                "'{}' is deprecated. {}".format(func.__name__, message),
                category=DeprecationWarning,
                stacklevel=stacklevel
            )
            return func(*args, **kwargs)
        return _func
    return _decorator
728292
def _get_param_names(cls):
        """"""
        # fetch the constructor or the original constructor before
        # deprecation wrapping if any
        init = getattr(cls.__init__, 'deprecated_original', cls.__init__)
        if init is object.__init__:
            # No explicit constructor to introspect
            return []

        # introspect the constructor arguments to find the model parameters
        # to represent
        init_signature = signature(init)
        # Consider the constructor parameters excluding 'self'
        parameters = [p for p in init_signature.parameters.values()
                      if p.name != 'self' and p.kind != p.VAR_KEYWORD]
        # Extract and sort argument names excluding 'self'
        parameters = set([p.name for p in parameters])

        # recurse
        for superclass in cls.__bases__:
            try:
                parameters.update(superclass._get_param_names())
            except AttributeError:
                # object and pygsp.graphs.Graph don't have this method
                pass

        return parameters
221436
def model_constructors(vk, model):
    
    model['constructors'] = []
    structs = [x for x in vk['registry']['types']['type']
               if x.get('@category') in {'struct', 'union'}]

    def parse_len(member):
        mlen = member.get('@len')
        if not mlen:
            return None

        if ',' in mlen:
            mlen = mlen.split(',')[0]

        if 'latex' in mlen or 'null-terminated' in mlen:
            return None

        return mlen

    for struct in structs:
        if 'member' not in struct:
            continue

        model['constructors'].append({
            'name': struct['@name'],
            'members': [{
                'name': x['name'],
                'type': x['type'],
                'default': x.get('@values'),
                'len': parse_len(x)
            } for x in struct['member']]
        })
268097
function (args) {
  var i;
  if (false === (this instanceof Model)) throw new Error('new operator required');
  this.attributes = [new Attribute('id', 'ID')];
  args = args || {};
  this.modelType = args.modelType || "Model";
  if (args.attributes) {
    for (i in args.attributes) {
      if (args.attributes.hasOwnProperty(i))
        this.attributes.push(args.attributes[i]);
    }
  }
  var unusedProperties = getInvalidProperties(args, ['modelType', 'attributes']);
  var errorList = this.getObjectStateErrors(); // before leaving make sure valid Model
  for (i = 0; i < unusedProperties.length; i++) errorList.push('invalid property: ' + unusedProperties[i]);
  if (errorList.length > 1) throw new Error('error creating Model: multiple errors');
  if (errorList.length) throw new Error('error creating Model: ' + errorList[0]);
  // Validations done
  this._eventListeners = [];
  this._errorConditions = {};
  for (i = 0; i < this.attributes.length; i++) {
   this.attributes[i].model = this;
  }
}
713685
def get_direct_fields_from_model(model_class):
    
    direct_fields = []
    all_fields_names = _get_all_field_names(model_class)
    for field_name in all_fields_names:
        field, model, direct, m2m = _get_field_by_name(model_class, field_name)
        if direct and not m2m and not _get_remote_field(field):
            direct_fields += [field]
    return direct_fields
188688
private void buildModel() {
    DeepLearningModel cp = null;
    if (checkpoint == null) {
      cp = initModel();
      cp.start_training(null);
    } else {
      final DeepLearningModel previous = UKV.get(checkpoint);
      if (previous == null) throw new IllegalArgumentException("Checkpoint not found.");
      Log.info("Resuming from checkpoint.");
      if (n_folds != 0) {
        throw new UnsupportedOperationException("n_folds must be 0: Cross-validation is not supported during checkpoint restarts.");
      }
      else {
        ((ValidatedJob)previous.job()).xval_models = null; //remove existing cross-validation keys after checkpoint restart
      }
      if (source == null || (previous.model_info().get_params().source != null && !Arrays.equals(source._key._kb, previous.model_info().get_params().source._key._kb))) {
        throw new IllegalArgumentException("source must be the same as for the checkpointed model.");
      }
      autoencoder = previous.model_info().get_params().autoencoder;
      if (!autoencoder && (response == null || !source.names()[source.find(response)].equals(previous.responseName()))) {
        throw new IllegalArgumentException("response must be the same as for the checkpointed model.");
      }
//      if (!autoencoder && (response == null || !Arrays.equals(response._key._kb, previous.model_info().get_params().response._key._kb))) {
//        throw new IllegalArgumentException("response must be the same as for the checkpointed model.");
//      }
      if (Utils.difference(ignored_cols, previous.model_info().get_params().ignored_cols).length != 0
              || Utils.difference(previous.model_info().get_params().ignored_cols, ignored_cols).length != 0) {
        ignored_cols = previous.model_info().get_params().ignored_cols;
        Log.warn("Automatically re-using ignored_cols from the checkpointed model.");
      }
      if ((validation == null) == (previous._validationKey != null)
              || (validation != null && validation._key != null && previous._validationKey != null
              && !Arrays.equals(validation._key._kb, previous._validationKey._kb))) {
        throw new IllegalArgumentException("validation must be the same as for the checkpointed model.");
      }
      if (classification != previous.model_info().get_params().classification) {
        Log.warn("Automatically switching to " + ((classification=!classification) ? "classification" : "regression") + " (same as the checkpointed model).");
      }
      epochs += previous.epoch_counter; //add new epochs to existing model
      Log.info("Adding " + String.format("%.3f", previous.epoch_counter) + " epochs from the checkpointed model.");
      try {
        final DataInfo dataInfo = prepareDataInfo();
        cp = new DeepLearningModel(previous, destination_key, job_key, dataInfo);
        cp.write_lock(self());
        cp.start_training(previous);
        assert(state==JobState.RUNNING);
        final DeepLearning A = cp.model_info().get_params();
        Object B = this;
        for (Field fA : A.getClass().getDeclaredFields()) {
          if (Utils.contains(cp_modifiable, fA.getName())) {
            if (!expert_mode && Utils.contains(expert_options, fA.getName())) continue;
            for (Field fB : B.getClass().getDeclaredFields()) {
              if (fA.equals(fB)) {
                try {
                  if (fB.get(B) == null || fA.get(A) == null || !fA.get(A).toString().equals(fB.get(B).toString())) { // if either of the two parameters is null, skip the toString()
                    if (fA.get(A) == null && fB.get(B) == null) continue; //if both parameters are null, we don't need to do anything
                    Log.info("Applying user-requested modification of '" + fA.getName() + "': " + fA.get(A) + " -> " + fB.get(B));
                    fA.set(A, fB.get(B));
                  }
                } catch (IllegalAccessException e) {
                  e.printStackTrace();
                }
              }
            }
          }
        }
        if (A.n_folds != 0) {
          Log.warn("Disabling cross-validation: Not supported when resuming training from a checkpoint.");
          A.n_folds = 0;
        }
        cp.update(self());
      } finally {
        if (cp != null) cp.unlock(self());
      }
    }
    trainModel(cp);
    cp.stop_training();
  }
48327
def _set_attribute_as_deprecated(attribute)
      original_attribute_method = instance_method(attribute.to_sym)

      klass = self
      define_method attribute.to_sym do |*args|
        backtrace_cleaner = ActiveSupport::BacktraceCleaner.new

        backtrace = backtrace_cleaner.clean(caller)

        klass._notify_deprecated_attribute_call({klass: self, attribute: attribute, args: args, backtrace: backtrace})

        # Call the original attribute method.
        original_attribute_method.bind(self).call(*args)
      end
    end
1039727
public boolean usesStandardModel(XLog log) {
		String model = extractModel(log);
		if (model == null) {
			return false;
		} else if (model.trim().equals(VALUE_MODEL_STANDARD)) {
			return true;
		} else {
			return false;
		}
	}
522294
def model_class
      if WillFilter::Config.require_filter_extensions?
        raise WillFilter::FilterException.new("model_class method must be overloaded in the extending class.")
      end

      if model_class_name.blank?
        raise WillFilter::FilterException.new("model_class_name was not specified.")
      end

      @model_class ||= model_class_name.constantize
    end
1010056
def deprecated(use_instead=None):
    """"""

    def wrapped(func):
        @wraps(func)
        def new_func(*args, **kwargs):
            message = "Call to deprecated function %s." % func.__name__
            if use_instead:
                message += " Use %s instead." % use_instead
            if not DISABLE_WARNINGS:
                warn(message, stacklevel=3)
            return func(*args, **kwargs)
        return new_func
    return wrapped
785801
function() {
            var supportsPropertyDescriptors = this.supportsPropertyDescriptors();

            ariaUtilsArray.forEach(this._deprecatedProperties, function(property) {
                // ----------------------------------------------- destructuring

                var name = property.name;
                var type = property.type;
                var underlying = property.underlying;
                var loggingMessage = property.loggingMessage;
                var loggingMessageArguments = property.loggingMessageArguments;

                // -------------------------------------------------- processing

                var self = this;

                if (type == "attribute" && supportsPropertyDescriptors) {
                    var prefixedName = "_" + name;
                    this[prefixedName] = this[name];

                    Object.defineProperty(this, name, {
                        get : function () {
                            self.$logWarn(loggingMessage, loggingMessageArguments);
                            return self[prefixedName];
                        },
                        set : function (value) {
                            self.$logWarn(loggingMessage, loggingMessageArguments);
                            self[prefixedName] = value;
                        }
                    });
                } else if (type == "method") {
                    this[name] = function() {
                        self.$logWarn(loggingMessage, loggingMessageArguments);
                        return underlying.apply(self, arguments);
                    };
                }
            }, this);
        }
77926
public static void resetModelClass() {
		ModelFactory.modelClass = DefaultModelImpl.class;
    	System.err.println("[INFO] Reset model-class: " + ModelFactory.modelClass.getName());
	}
328259
def const_missing mod
    if Rib.const_defined?(mod)
      Rib.warn("Using #{mod} is deprecated, please change to Rib::#{mod}",
               "This compatibility layer would be removed in Rib 1.6+",
               "Called: #{caller.first}")
      Rib.const_get(mod)
    else
      super
    end
  end
1156979
function (source) {
  if (false === (this instanceof List)) throw new Error('new operator required');
  if (source instanceof Model) {
    this.model = source;
  } else if (source instanceof View) {
    this.view = source;
    this.model = this.view.primaryModel;
  } else {
    throw new Error('argument required: model');
  }
  this.attributes = source.attributes;
  this._items = [];
  this._itemIndex = -1;
}