Returns the options specified as argument to this command.
968388
def options(self):
        
        if self._options is None:
            self._options = Option.View(self)
        return self._options
889273
@SuppressWarnings("static-access")
    private Options createCommandLineOptions() {
        final Options options = new Options();
        addStandardOptions(options);
        addAdvancedOptions(options);
        addDeprecatedOptions(options);
        return options;
    }
397128
def __get_options(self, rouge_args=None):
        
        if self.args:
            options = self.args.split()
        elif rouge_args:
            options = rouge_args.split()
        else:
            options = [
                '-e', self._data_dir,
                '-c', 95,
                '-2',
                '-1',
                '-U',
                '-r', 1000,
                '-n', 4,
                '-w', 1.2,
                '-a',
                ]
            options = list(map(str, options))

        options = self.__add_config_option(options)
        return options
160544
def configured_options(self):
        """"""
        stdout_lines = self._check_output(['config', '--list']).splitlines()
        return {key: value for key, value in [line.split('=') for line in stdout_lines]}
1152611
def arguments(self):
        """"""
        if 'arguments' in self.attributes:
            LOGGER.warning(
                "WARNING: 'arguments' use in OSU yaml configuration file is deprecated. Please use 'options'!"
            )
            arguments = self.attributes['arguments']
            if isinstance(arguments, dict):
                return arguments
            else:
                return {k: arguments for k in self.categories}
        elif 'options' in self.attributes:
            options = self.attributes['options']
            if isinstance(options, dict):
                return options
            else:
                return {k: options for k in self.categories}
423057
def _get_args():
    """"""
    parser = argparse.ArgumentParser(description=__doc__)
    # add the argument for the Super Mario Bros environment to run
    parser.add_argument('--rom', '-r',
        type=str,
        help='The path to the ROM to play.',
        required=True,
    )
    # add the argument for the mode of execution as either human or random
    parser.add_argument('--mode', '-m',
        type=str,
        default='human',
        choices=['human', 'random'],
        help='The execution mode for the emulation.',
    )
    # add the argument for the number of steps to take in random mode
    parser.add_argument('--steps', '-s',
        type=int,
        default=500,
        help='The number of random steps to take.',
    )
    return parser.parse_args()
406998
def argument(value, options = {})
      return unless @shell.applicable?(options)
      value = value.to_s
      if @shell.requires_escaping?(value)
        value = @shell.escape_value(value)
      end
      @command << ' ' << value
      @last_arg = :argument
    end
746720
protected Options getOptions() throws MojoExecutionException {
        File persistence = ensurePersistenceXml();

        Options opts = new Options();
        if (toolProperties != null) {
            opts.putAll(toolProperties);
        }
        opts.put(OPTION_PROPERTIES_FILE, persistence.getAbsolutePath());

        if (connectionDriverName != null) {
            opts.put(OPTION_CONNECTION_DRIVER_NAME, connectionDriverName);
        }

        if (connectionProperties != null) {
            opts.put(OPTION_CONNECTION_PROPERTIES, connectionProperties);
        }

        // put the standard options into the list also
        opts.put(OPTION_ADD_DEFAULT_CONSTRUCTOR, Boolean.toString(addDefaultConstructor));
        opts.put(OPTION_ENFORCE_PROPERTY_RESTRICTION, Boolean.toString(enforcePropertyRestrictions));
        opts.put(OPTION_USE_TEMP_CLASSLOADER, Boolean.toString(tmpClassLoader));

        return opts;
    }
341734
public org.tensorflow.distruntime.TraceOpts getOptions() {
    return options_ == null ? org.tensorflow.distruntime.TraceOpts.getDefaultInstance() : options_;
  }
555430
function getOpts (processArgv) {
  return optimist(processArgv)
    .usage(help())
    // Show version
    .boolean("version")
    .describe("version", "Show version and exit")
    // Help options (converted to help command)
    .boolean("h")
    .describe("h", "Show help")
    .alias("h", "help")
    // Update notification control
    .boolean("no-notifier")
    .describe("no-notifier", "Disable update notifier");
}
243015
def get_args
      bin_path = get_binpath
      utc      = get_utc
      check_bin_path(bin_path)
      return [bin_path, utc]
    rescue => e
      raise
    end
1204172
def add_command_line_options(cls, parser):
        """"""
        if "add_argument" in dir(parser):
            return cls.add_command_line_options_argparse(parser)
        else:
            return cls.add_command_line_options_optparse(parser)
1301250
static Options getProgramSpecificOptions(Options options) {
		options.addOption(JAR_OPTION);
		options.addOption(CLASS_OPTION);
		options.addOption(PARALLELISM_OPTION);
		options.addOption(ARGS_OPTION);
		return options;
	}
575620
private Argument[] getArguments()
	{
		Argument[] args = new Argument[auxArguments.size() + arguments.size()];

		for (int i = 0; i < auxArguments.size(); ++i)
		{
			args[i] = auxArguments.elementAt(i);
		}
		for (int j = 0; j < arguments.size(); ++j)
		{
			Command cmd = arguments.elementAt(j);

			if (cmd.getStatus() >= Command.COMMAND_EXECUTED)
			{
				args[auxArguments.size() + j] = cmd.getResult();
			}
			else
			{
				// System.out.println("arg: " + cmd.getResultValue());
				args = null;
				break;
			}
		}
		return args;
	}
1321661
def _arg2opt(arg):
    '''
    
    '''
    res = [o for o, a in option_toggles.items() if a == arg]
    res += [o for o, a in option_flags.items() if a == arg]
    return res[0] if res else None
1312452
def get_args():
    
    parser = argparse.ArgumentParser("FashionMNIST")
    parser.add_argument("--batch_size", type=int, default=128, help="batch size")
    parser.add_argument("--optimizer", type=str, default="SGD", help="optimizer")
    parser.add_argument("--epochs", type=int, default=200, help="epoch limit")
    parser.add_argument(
        "--learning_rate", type=float, default=0.001, help="learning rate"
    )
    parser.add_argument("--cutout", action="store_true", default=False, help="use cutout")
    parser.add_argument("--cutout_length", type=int, default=8, help="cutout length")
    parser.add_argument(
        "--model_path", type=str, default="./", help="Path to save the destination model"
    )
    return parser.parse_args()
1170864
public static String[] processOptions(Context cx, String args[]) {
        for (int i=0; i < args.length; i++) {
            String arg = args[i];
            if (!arg.startsWith("-")) {
                String[] result = new String[args.length - i];
                for (int j=i; j < args.length; j++)
                    result[j-i] = args[j];
                return result;
            }
            if (arg.equals("-version")) {
                if (++i == args.length)
                    usage(arg);
                double d = Context.toNumber(args[i]);
                if (d != d)
                    usage(arg);
                cx.setLanguageVersion((int) d);
                continue;
            }
            usage(arg);
        }
        return new String[0];
    }