Return the options to run this JVM with.

    These are options to the JVM itself, such as -Dfoo=bar, -Xmx=1g, -XX:-UseParallelGC and so on.

    Thus named because get_options() already exists (and returns this object's Pants options).
191178
def get_jvm_options(self):
    
    ret = []
    for opt in self.get_options().options:
      ret.extend(safe_shlex_split(opt))

    if (self.get_options().debug or
        self.get_options().is_flagged('debug_port') or
        self.get_options().is_flagged('debug_args')):
      debug_port = self.get_options().debug_port
      ret.extend(arg.format(debug_port=debug_port) for arg in self.get_options().debug_args)
    return ret
333334
public org.tensorflow.framework.RunOptions getOptions() {
    return options_ == null ? org.tensorflow.framework.RunOptions.getDefaultInstance() : options_;
  }
508638
def get_options(self):
        
        super(ScriptBaseWithConfig, self).get_options()

        self.config_dir = os.path.abspath(os.path.expanduser(self.options.config_dir
            or os.environ.get('PYRO_CONFIG_DIR', None)
            or self.CONFIG_DIR_DEFAULT))
        load_config.ConfigLoader(self.config_dir).load(self.OPTIONAL_CFG_FILES + self.options.config_file)
        if self.options.debug:
            config.debug = True

        for key_val in self.options.defines:
            try:
                key, val = key_val.split('=', 1)
            except ValueError, exc:
                raise error.UserError("Bad config override %r (%s)" % (key_val, exc))
            else:
                setattr(config, key, load_config.validate(key, val))
353234
private RuntimeOptions getRuntimeOptions() {
    RuntimeOptions opts = new RuntimeOptions();
    opts.setSeed((int) get_params().getOrMakeRealSeed());
    opts.setUseGPU(get_params()._gpu);
    opts.setDeviceID(get_params()._device_id);
    return opts;
  }
1313538
public alluxio.grpc.CreateDirectoryPOptions getOptions() {
    return options_ == null ? alluxio.grpc.CreateDirectoryPOptions.getDefaultInstance() : options_;
  }
251319
def parse_options(self, prog_name, arguments):
        """"""
        # Don't want to load configuration to just print the version,
        # so we handle --version manually here.
        if '--version' in arguments:
            self.exit_status(self.version, fh=sys.stdout)
        parser = self.create_parser(prog_name)
        options, args = parser.parse_args(arguments)
        return options, args
837055
def get_options(self):
        
        args = self.parse_options(self.args)

        if args:
            self.directory = args[0]

        if self.develop:
            self.skiptag = True
        if not self.develop:
            self.develop = self.defaults.develop
        if not self.develop:
            self.infoflags = self.setuptools.infoflags

        if not self.formats:
            self.formats = self.defaults.formats

        for format in self.formats:
            if format == 'zip':
                self.distributions.append(('sdist', ['--formats="zip"']))
            elif format == 'gztar':
                self.distributions.append(('sdist', ['--formats="gztar"']))
            elif format == 'egg':
                self.distributions.append(('bdist', ['--formats="egg"']))
            elif format == 'wheel':
                self.distributions.append(('bdist_wheel', []))

        if not self.distributions:
            self.distributions.append(('sdist', ['--formats="zip"']))

        if self.list:
            self.list_locations()

        if not self.locations:
            self.locations.extend(self.locations.get_default_location())

        if not (self.skipregister and self.skipupload):
            if not (self.get_skipregister() and self.get_skipupload()):
                self.locations.check_empty_locations()
            self.locations.check_valid_locations()

        if len(args) > 1:
            if self.urlparser.is_url(self.directory):
                self.branch = args[1]
            elif self.urlparser.is_ssh_url(self.directory):
                self.branch = args[1]
            else:
                err_exit('mkrelease: invalid arguments\n%s' % USAGE)

        if len(args) > 2:
            err_exit('mkrelease: too many arguments\n%s' % USAGE)
1102165
public alluxio.grpc.GetUfsInfoPOptionsOrBuilder getOptionsOrBuilder() {
    return options_ == null ? alluxio.grpc.GetUfsInfoPOptions.getDefaultInstance() : options_;
  }
635225
def get_options(self):
        
        choices = self._field_choices()
        if choices:
            return [c[1] for c in choices]
        else:
            return self.model.objects.\
                order_by(self.name).\
                values_list(self.name, flat=True)
626418
def getOption(self, name):
    
    name = name.strip()
    for o in self.options:
      if o.short == name or o.long == name:
        return o
    raise InterfaceException("No such option: " + name)
1020937
@Override
  protected Object getOptionValue(Queue<String> argq) {
    String name = argq.remove();
    File file = new File(name);
    if (mustExist && !file.isFile()) {
      System.err.println("File does not exist: '" + name + "'");
      System.exit(1);
    }
    return file;
  }
923650
def GetOptions(self):
    
    values = [c.GetValue()
              for c in chain(*self.widgets)
              if c.GetValue() is not None]
    return ' '.join(values)
1006839
def _get_options(options_file=None):
    

    if options_file is not None:
        with open(options_file, 'r') as opt_file:
            options = json.loads(opt_file.read())
    else:
        options = {}
    return options
321253
def get_options():
    """"""
    options = collections.defaultdict(list)
    for opt_class in config_factory.get_options():
        if not issubclass(opt_class, config_base.Options):
            continue
        config_options = opt_class(None)
        options[config_options.group_name].extend(config_options.list())
    return [(key, value) for key, value in options.items()]
1331166
public alluxio.grpc.SetAclPOptions getOptions() {
    return options_ == null ? alluxio.grpc.SetAclPOptions.getDefaultInstance() : options_;
  }
898835
public alluxio.grpc.RunPOptionsOrBuilder getOptionsOrBuilder() {
    return options_ == null ? alluxio.grpc.RunPOptions.getDefaultInstance() : options_;
  }
10185
def parse_options():
	

	parser = optparse.OptionParser(usage=USAGE, version=ontospy.VERSION)

	parser.add_option("-p", "--port",
			action="store", type="int", default=DEFAULT_PORT, dest="port",
			help="A number specifying which port to use for the server.")

	opts, args = parser.parse_args()

	# if not opts.all and not opts.query:
	#	parser.print_help()
	#	sys.exit(0)

	return opts, args