Load test parameters.
504908
private function loadParameters(ContainerBuilder $container, array $config)
    {
        // Store config in parameters array to be passed into the DrupalContext.
        $drupal_parameters = array();
        foreach ($config as $key => $value) {
            $drupal_parameters[$key] = $value;
        }
        $container->setParameter('drupal.parameters', $drupal_parameters);

        $container->setParameter('drupal.region_map', $config['region_map']);
    }
865405
def config_load(ctx, param, value):
    """"""
    if ctx.obj is None:
        ctx.obj = {}

    ctx.obj['config_path'] = value
    ctx.obj['config'] = read_config(value)
    return value
1199979
def parameters(self, params):
        
        array = JavaArray(jobject=JavaArray.new_instance("weka.core.setupgenerator.AbstractParameter", len(params)))
        for idx, obj in enumerate(params):
            array[idx] = obj.jobject
        javabridge.call(self.jobject, "setParameters", "([Lweka/core/setupgenerator/AbstractParameter;)V", array.jobject)
122319
def parameters(self, namespaced=False):
        """"""
        if namespaced:
            return json.loads(json.dumps(self.args[0]['parameters']), object_hook=lambda d: SimpleNamespace(**d))
        else:
            return self.args[0].get('parameters')
383518
def _load_resource(self):
        """"""

        url = self._url
        if self._params:
            url += '?{0}'.format(six.moves.urllib_parse.urlencode(self._params))

        r = getattr(self._session, self._meta.get_method.lower())(url)

        if r.status_code == 404:
            raise NotFoundException('Server returned 404 Not Found for the URL {0}'.format(self._url))
        elif not 200 <= r.status_code < 400:
            raise HTTPException('Server returned {0} ({1})'.format(r.status_code, r.reason), r)

        data = self._meta.deserializer.to_dict(r.text)
        self.populate_field_values(data)
160443
private void loadEvalParameters() {
    this.evalParser.addArgument("-c","--component")
         .required(true)
         .choices("pos","lemma")
         .help("Choose component for evaluation");
    this.evalParser.addArgument("-m", "--model")
        .required(true)
        .help("Choose model");
    this.evalParser.addArgument("-t", "--testSet")
        .required(true)
        .help("Input testset for evaluation");
    this.evalParser.addArgument("--evalReport")
        .required(false)
        .choices("brief", "detailed", "error")
        .help("Choose type of evaluation report; defaults to brief");
  }
559428
@SuppressWarnings("checkstyle:emptyblock")
	private void load() {
		recordMessage("Loading parameters");
		File cwd = new File(".");
		String workingDir;

		try {
			workingDir = cwd.getCanonicalPath();
		} catch (IOException ex) {
			workingDir = "UNKNOWN";
		}

		recordMessage("Working directory is " + workingDir);

		for (String resourceName : PARAMETER_LOAD_ORDER) {
			loadTop(resourceName);
		}

		if (getBoolean(USE_SYSTEM_PROPERTIES)) {
			recordMessage("Loading from system properties");
			load(System.getProperties(), "System Properties", true);
		}

		// Now perform variable substitution.
		do {
			// Do nothing while loop
		} while (substitute());

		if (getBoolean(DUMP)) {
			// Can't use logging infrastructure here, so dump to console
			log(getDebuggingInfo());
			log(getMessages());
		}

		// We don't want the StringBuffer hanging around after 'DUMP'.
		clearMessages();

		// Now move any parameters with the system parameters prefix into the real system parameters.
		Properties systemProperties = getSubProperties(SYSTEM_PARAMETERS_PREFIX, true);
		System.getProperties().putAll(systemProperties);
	}
1117515
def load_parameters(self, path):
        
        nn.load_parameters(path)
        for v in self.get_modules():
            if not isinstance(v, tuple):
                continue
            prefix, module = v
            for k, v in module.__dict__.items():
                if not isinstance(v, nn.Variable):
                    continue
                pname = k
                name = "{}/{}".format(prefix, pname)
                # Substitute
                param0 = v
                param1 = nn.parameter.pop_parameter(name)
                if param0 is None:
                    raise ValueError(
                        "Model does not have {} parameter.".format(name))
                param0.d = param1.d.copy()
                nn.logger.info("`{}` loaded.)".format(name))
279010
def build_user_requested_parameters(request, meta):
    """"""

    postParameters = {}
    getParameters = {}
    files = {}

    # Add parameters requested by the server
    if 'user_info' in meta:
        for prop in meta['user_info']:

            # Test if the value exist, otherwise return None
            value = None
            if hasattr(request.user, prop) and prop in settings.PIAPI_USERDATA:
                value = getattr(request.user, prop)
            else:
                raise Exception('requested user attribute "%s", '
                                'does not exist or requesting is not allowed' % prop)

            # Add informations to get or post parameters, depending on the current method
            if request.method == 'POST':
                postParameters['ebuio_u_' + prop] = value
            else:
                getParameters['ebuio_u_' + prop] = value

    return (getParameters, postParameters, files)
818466
public function loadEverything($showTests = false)
    {
        $this->showProgress('Config loaded from '.Config::getConfigPath());

        $this->loadTesters();

        $this->loadProjects();

        $this->loadTests($showTests);
    }
742880
private void loadAnnotateParameters() {
    this.annotateParser.addArgument("-m", "--model")
        .required(true)
        .help("It is required to provide a POS tagging model.");
    this.annotateParser.addArgument("-lm", "--lemmatizerModel")
         .required(true)
         .help("It is required to provide a lemmatizer model.");
    this.annotateParser.addArgument("-l", "--language")
        .choices("de", "en", "es", "eu", "fr", "gl", "it", "nl")
        .required(false)
        .help("Choose a language.");

    this.annotateParser.addArgument("--beamSize")
        .required(false)
        .setDefault(DEFAULT_BEAM_SIZE)
        .help("Choose beam size for decoding, it defaults to 3.");
    annotateParser.addArgument("-o", "--outputFormat")
        .required(false)
        .choices("naf", "conll")
        .setDefault(Flags.DEFAULT_OUTPUT_FORMAT)
        .help("Choose output format; it defaults to NAF.\n");
    this.annotateParser.addArgument("-mw", "--multiwords")
        .action(Arguments.storeTrue())
        .help("Use to detect and process multiwords.\n");
    this.annotateParser.addArgument("-d", "--dictag")
        .action(Arguments.storeTrue())
        .help("Post process POS tagger output with a monosemic dictionary.\n");
    this.annotateParser.addArgument("-a","--allMorphology")
        .action(Arguments.storeTrue())
        .help("Print all the POS tags and lemmas before disambiguation.\n");
  }
544324
def parameters(self, parameters):
        """"""
        # pylint: disable=attribute-defined-outside-init
        self._parameters = NocaseDict()
        if parameters:
            try:
                # This is used for iterables:
                iterator = parameters.items()
            except AttributeError:
                # This is used for dictionaries:
                iterator = parameters
            for item in iterator:
                if isinstance(item, CIMParameter):
                    key = item.name
                    value = item
                elif isinstance(item, tuple):
                    key, value = item
                else:
                    raise TypeError(
                        _format("Input object for parameters has invalid item "
                                "in iterable: {0!A}", item))
                self.parameters[key] = value
704495
def load(param):
    
    return (
        Pattern(param) if isinstance(param, str)
        else param if param is not None
        else Null()
    )
1231911
def load_parameters(self, filename, ctx=mx.cpu()): # pylint: disable=arguments-differ
        
        self.lm_model.load_parameters(filename, ctx=ctx)
88221
def __init_config_params(self, config):
        """"""
        if self.version >= (2, 4):
            params = config.get('setParameter', {})
            # Set enableTestCommands by default but allow enableTestCommands:0.
            params.setdefault('enableTestCommands', 1)
            # Reduce transactionLifetimeLimitSeconds for faster driver testing.
            if self.version >= (4, 1) and not self.is_mongos:
                params.setdefault('transactionLifetimeLimitSeconds', 3)
            # Increase transaction lock timeout to reduce the chance that tests
            # fail with LockTimeout: "Unable to acquire lock {...} within 5ms".
            if self.version >= (4, 0) and not self.is_mongos:
                params.setdefault('maxTransactionLockRequestTimeoutMillis', 25)
            config['setParameter'] = params

        compressors = config.get('networkMessageCompressors')
        if compressors is None:
            if self.version >= (4, 1, 7):
                # SERVER-38168 added zstd support in 4.1.7.
                config['networkMessageCompressors'] = 'zstd,zlib,snappy,noop'
            elif self.version >= (3, 5, 9):
                # SERVER-27310 added zlib support in 3.5.9.
                config['networkMessageCompressors'] = 'zlib,snappy,noop'
            elif self.version >= (3, 4):
                config['networkMessageCompressors'] = 'snappy,noop'
636406
async def async_load_parameters(self):
        """"""
        zones = await self._async_get_data('zone')
        areas = await self._async_get_data('area')

        if not zones or not areas:
            return False

        for spc_area in areas:
            area = Area(self, spc_area)
            area_zones = [Zone(area, z) for z in zones
                          if z['area'] == spc_area['id']]
            area.zones = area_zones
            self._areas[area.id] = area
            self._zones.update({z.id: z for z in area_zones})

        return True
730108
def _check_load_parameters(self, **kwargs):
        
        rset = self._meta_data['required_load_parameters']
        check = _missing_required_parameters(rset, **kwargs)
        if check:
            check.sort()
            error_message = 'Missing required params: %s' % check
            raise MissingRequiredReadParameter(error_message)