Generates .lst file.
    Parameters
    ----------
    args: object that contains all the arguments
485799
def make_list(args):
    
    image_list = list_image(args.root, args.recursive, args.exts)
    image_list = list(image_list)
    if args.shuffle is True:
        random.seed(100)
        random.shuffle(image_list)
    N = len(image_list)
    chunk_size = (N + args.chunks - 1) // args.chunks
    for i in range(args.chunks):
        chunk = image_list[i * chunk_size:(i + 1) * chunk_size]
        if args.chunks > 1:
            str_chunk = '_%d' % i
        else:
            str_chunk = ''
        sep = int(chunk_size * args.train_ratio)
        sep_test = int(chunk_size * args.test_ratio)
        if args.train_ratio == 1.0:
            write_list(args.prefix + str_chunk + '.lst', chunk)
        else:
            if args.test_ratio:
                write_list(args.prefix + str_chunk + '_test.lst', chunk[:sep_test])
            if args.train_ratio + args.test_ratio < 1.0:
                write_list(args.prefix + str_chunk + '_val.lst', chunk[sep_test + sep:])
            write_list(args.prefix + str_chunk + '_train.lst', chunk[sep_test:sep_test + sep])
1315205
def main(argv=None):
    
    if not argv:
        argv = sys.argv[1:]

    parser = argparse.ArgumentParser(description=_HELP_TEXT)
    parser.add_argument('input', nargs='?', default=None)
    parser.add_argument('output', nargs='?', default=None)
    parser.add_argument('--version', action='version',
                        version='%(prog)s ' + get_version())
    args = parser.parse_args(argv)

    if not args.input:
        print("No file specified", file=sys.stderr)
        sys.exit(1)

    try:
        with open(args.input, 'r') as f:
            res = mangle(f.read())
            if not args.output:
                print(res, end='')
            else:
                with open(args.output, 'w') as o:
                    o.write(res)
    except Exception as ex:
        print("Error mangling {}: {!s}".format(args.input, ex),
              file=sys.stderr)
        sys.exit(1)
145663
def main(argv):
    
    init()

    if OPTIONS.StdErrFileName.value:
        OPTIONS.stderr.value = open('wt', OPTIONS.StdErrFileName.value)

    asmlex.FILENAME = OPTIONS.inputFileName.value = argv[0]
    input_ = open(OPTIONS.inputFileName.value, 'rt').read()
    assemble(input_)
    generate_binary(OPTIONS.outputFileName.value, OPTIONS.output_file_type)
360887
def _map_arguments(self, args):
        
        data = args.get('data')
        comp = args.get('comp')
        ft1file = args.get('ft1file')
        ft2file = args.get('ft2file')
        scratch = args.get('scratch', None)
        dry_run = args.get('dry_run', None)

        self._set_link('split-and-mktime', SplitAndMktime_SG,
                       comp=comp, data=data,
                       hpx_order_max=args.get('hpx_order_ccube', 9),
                       ft1file=ft1file,
                       ft2file=ft2file,
                       do_ltsum=args.get('do_ltsum', False),
                       scratch=scratch,
                       dry_run=dry_run)

        self._set_link('coadd-split', CoaddSplit_SG,
                       comp=comp, data=data,
                       ft1file=ft1file)

        self._set_link('ltsum', Gtltsum_SG,
                       comp=comp, data=data,
                       ft1file=args['ft1file'],
                       dry_run=dry_run)

        self._set_link('expcube2', Gtexpcube2_SG,
                       comp=comp, data=data,
                       hpx_order_max=args.get('hpx_order_expcube', 5),
                       dry_run=dry_run)
127226
def cmd_ls(self, *args):
        
        cmd_str = ' '.join(['ls'] + list(args))
        self.plugin.exec_shell(cmd_str)
118209
def main(argv=None):
    """"""
    parser = ArgumentParser(prog="pygenstub")
    parser.add_argument("--version", action="version", version="%(prog)s " + __version__)
    parser.add_argument("files", nargs="*", help="generate stubs for given files")
    parser.add_argument(
        "-m",
        "--module",
        action="append",
        metavar="MODULE",
        dest="modules",
        default=[],
        help="generate stubs for given modules",
    )
    parser.add_argument(
        "-o", "--output", metavar="PATH", dest="out_dir", help="change the output directory"
    )
    parser.add_argument(
        "--generic", action="store_true", default=False, help="generate generic stubs"
    )
    parser.add_argument("--debug", action="store_true", help="enable debug messages")

    argv = argv if argv is not None else sys.argv
    arguments = parser.parse_args(argv[1:])

    # set debug mode
    if arguments.debug:
        logging.basicConfig(level=logging.DEBUG)
        _logger.debug("running in debug mode")

    out_dir = arguments.out_dir if arguments.out_dir is not None else ""
    if (out_dir == "") and (len(arguments.modules) > 0):
        print("Output directory must be given when generating stubs for modules.")
        sys.exit(1)

    modules = []
    for path in arguments.files:
        paths = Path(path).glob("**/*.py") if Path(path).is_dir() else [Path(path)]
        for source in paths:
            if str(source).startswith(os.path.pardir):
                source = source.absolute().resolve()
            if (out_dir != "") and source.is_absolute():
                source = source.relative_to(source.root)
            destination = Path(out_dir, source.with_suffix(".pyi"))
            modules.append((source, destination))

    for mod_name in arguments.modules:
        modules.extend(get_pkg_paths(mod_name, out_dir))

    for source, destination in modules:
        _logger.info("generating stub for %s to path %s", source, destination)
        with source.open() as f:
            code = f.read()
        try:
            stub = get_stub(code, generic=arguments.generic)
        except Exception as e:
            print(source, "-", e, file=sys.stderr)
            continue

        if stub != "":
            if not destination.parent.exists():
                destination.parent.mkdir(parents=True)
            with destination.open("w") as f:
                f.write("# " + EDIT_WARNING + "\n\n" + stub)
582115
public static void main(String[] args) throws IOException {
	if (!checkArgs(args)) {
	    displayHelp();
	    return;
	}
	
	String modelDir = args[2];
	boolean isAll = (args[0].compareToIgnoreCase("-all") == 0);
	boolean isTrn = (args[0].compareToIgnoreCase("-trn") == 0);
	boolean isTst = (args[0].compareToIgnoreCase("-tst") == 0);
	boolean isCont = (args[0].compareToIgnoreCase("-cont") == 0); //TUNC
	
	// create option object
	Option option = new Option(modelDir);
	
	option.optionFile = args[4];
	
	option.readOptions();
	
	Data data = null;
	Dictionary dict = null;
	FeatureGen feaGen = null;
	Train train = null;
	Inference inference = null;
	Evaluation evaluation = null;
	Model model = null;
	
	PrintWriter foutModel = null;
	BufferedReader finModel = null;
	
	if (isAll) {
	    // both training and testing
	    
	    PrintWriter flog = option.openTrainLogFile();
	    if (flog == null) {
		System.out.println("Couldn't create training log file");
		return;
	    }
	    
	    foutModel = option.createModelFile();
	    if (foutModel == null) {
		System.out.println("Couldn't create model file");
		return;
	    }	    	    
	    
	    data = new Data(option);
	    data.readTrnData(option.modelDir + File.separator + option.trainDataFile);	    
	    data.readTstData(option.modelDir + File.separator + option.testDataFile);	    	    
	    
	    dict = new Dictionary(option, data);
	    dict.generateDict();
	    
	    feaGen = new FeatureGen(option, data, dict);
	    feaGen.generateFeatures();
	    
	    data.writeCpMaps(dict, foutModel);
	    data.writeLbMaps(foutModel);	    
	    
	    train = new Train();
	    inference = new Inference();
	    evaluation = new Evaluation();
	    
	    model = new Model(option, data, dict, feaGen, train, inference, evaluation);
	    model.doTrain(flog);	    	    
	    
	    model.doInference(model.data.tstData);
	    model.evaluation.evaluate(flog);
	    
	    dict.writeDict(foutModel);
	    feaGen.writeFeatures(foutModel);
	    
	    foutModel.close();
	}
	
	if (isTrn) {
	    // training only
	    
	    PrintWriter flog = option.openTrainLogFile();
	    if (flog == null) {
		System.out.println("Couldn't create training log file");
		return;
	    }	    

	    foutModel = option.createModelFile();
	    if (foutModel == null) {
		System.out.println("Couldn't create model file");
		return;
	    }
	    
	    data = new Data(option);
	    data.readTrnData(option.modelDir + File.separator + option.trainDataFile);	    
	    
	    dict = new Dictionary(option, data);
	    dict.generateDict();
	    
	    feaGen = new FeatureGen(option, data, dict);
	    feaGen.generateFeatures();
	    
	    data.writeCpMaps(dict, foutModel);
	    data.writeLbMaps(foutModel);	    	    

	    train = new Train();	    
	    
	    model = new Model(option, data, dict, feaGen, train, null, null);	    	    
	    model.doTrain(flog);	    
	    
	    dict.writeDict(foutModel);
	    feaGen.writeFeatures(foutModel);
	    
	    foutModel.close();
	}
	
	if (isTst) {
	    // testing only
	    
	    finModel = option.openModelFile();
	    if (finModel == null) {
		System.out.println("Couldn't open model file");
		return;
	    }	    
	    
	    data = new Data(option);
	    data.readCpMaps(finModel);
	    data.readLbMaps(finModel);	    
	    data.readTstData(option.modelDir + File.separator + option.testDataFile);	    
	
	    dict = new Dictionary(option, data);	    
	    dict.readDict(finModel);
	    
	    feaGen = new FeatureGen(option, data, dict);
	    feaGen.readFeatures(finModel);
	    
	    inference = new Inference();
	    evaluation = new Evaluation();
	    
	    model = new Model(option, data, dict, feaGen, null, inference, evaluation);	    
	    
	    model.doInference(model.data.tstData);
	    model.evaluation.evaluate(null);
	    
	    finModel.close();	    
	}	
	
	if (isCont){ //continue last training
		PrintWriter flog = option.openTrainLogFile(); //append
	    if (flog == null) {
		System.out.println("Couldn't create training log file");
		return;
	    }	 
		    
		finModel = option.openModelFile();
	    if (finModel == null) {
		System.out.println("Couldn't open model file");
		return;
	    }	    
	    
	    data = new Data(option);
	    data.readCpMaps(finModel);
	    data.readLbMaps(finModel);	    
	    data.readTstData(option.modelDir + File.separator + option.testDataFile);	    
	
	    dict = new Dictionary(option, data);	    
	    dict.readDict(finModel);
	    
	    feaGen = new FeatureGen(option, data, dict);
	    feaGen.readFeatures(finModel);
	    
	    inference = new Inference();
	    evaluation = new Evaluation();
	    
	    foutModel = option.createModelFile(); //overwrite the old model file
	    if (foutModel == null) {
			System.out.println("Couldn't create model file");
			return;
		    }
	    
	    model = new Model(option, data, dict, feaGen, train, inference, evaluation);
	    model.doTrain(flog);	    	    
	    
	    model.doInference(model.data.tstData);
	    model.evaluation.evaluate(flog);	
	    
	    foutModel.close();
	}
    }
1192051
def _get_args_contents(self):
        
        return ' '.join(
            '%s=%s' % (key, shlex_quote(str(self.args[key])))
            for key in self.args
        ) + ' '
702389
def fill_arg(self, *args):
        
        missing = self.missing_vars()
        if len(args) == len(missing) == 1:
            self.setval(missing[0], args[0])
482214
def append_args(self, arg):
      
      debug.log("Adding Arguments: %s"%(arg))
      if isinstance(arg, (int,float)): self.args.append(str(arg))
      if isinstance(arg, str): self.args.append(arg)
      if isinstance(arg, list):
         if sys.version_info < (3, 0):
            self.args.extend([str(x) if not isinstance(x, (unicode)) else x.encode('utf-8') for x in arg])
         else:
            self.args.extend([str(x) for x in arg])
995601
def _read_arg(arg):
    

    # If arg is None, just return it back
    if arg is None:
        arg_out = arg

    else:
        # If len(arg) == 1 and arg[0] is a valid filepath, read it as a grp file
        if len(arg) == 1 and os.path.exists(arg[0]):
            arg_out = grp.read(arg[0])
        else:
            arg_out = arg

        # Make sure that arg_out is a list of strings
        assert isinstance(arg_out, list), "arg_out must be a list."
        assert type(arg_out[0]) == str, "arg_out must be a list of strings."

    return arg_out
610956
def main(args=None):
	""""""
	import sys, pprint
	from argparse import ArgumentParser, FileType
	parser = ArgumentParser(description=main.__doc__)
	parser.add_argument('infile',  nargs='?', type=FileType('rb'), default=sys.stdin.buffer,
		help='bencoded file (e.g. torrent) [Default: stdin]')
	parser.add_argument('outfile', nargs='?', type=FileType('w'), default=sys.stdout,
		help='python-syntax serialization [Default: stdout]')
	args = parser.parse_args(args)
	
	data = bdecode(args.infile)
	pprint.pprint(data, stream=args.outfile)
1271777
def _build_arguments(self):
        
        self._parser.add_argument(
            '--attach',
            type=bool,
            required=False,
            default=False,
            help="Attach to containers output?"
        )

        self._parser.add_argument(
            '--clean',
            type=bool,
            required=False,
            default=False,
            help="clean up everything that was created by freight forwarder at the end."
        )

        self._parser.add_argument(
            '--configs',
            type=bool,
            required=False,
            default=False,
            help="Would you like to inject configuration files?"
        )

        self._parser.add_argument(
            '-e', '--env',
            required=False,
            type=str,
            action='append',
            default=None,
            help='environment variables to create in the container at run time.'
        )

        self._parser.add_argument(
            '--test',
            type=bool,
            required=False,
            default=False,
            help="Run tests."
        )

        self._parser.add_argument(
            '--use-cache',
            required=False,
            action='store_true',
            default=False,
            help='Allow build to use cached image layers.'
        )
705085
def base_argparser(argv=()):
    
    global verbose
    verbose = _not_verbose

    _p = argparse.ArgumentParser(add_help=False)
    _p.add_argument('--debug', action='store_true', help="turn on all the show and verbose options (mainly for debugging pydeps itself)")
    _p.add_argument('--config', help="specify config file", metavar="FILE")
    _p.add_argument('--no-config', help="disable processing of config files", action='store_true')
    _p.add_argument('--version', action='store_true', help='print pydeps version')
    _p.add_argument('-L', '--log', help=textwrap.dedent('''
        set log-level to one of CRITICAL, ERROR, WARNING, INFO, DEBUG, NOTSET.
    '''))
    _args, argv = _p.parse_known_args(argv)

    if _args.log:
        loglevels = "CRITICAL DEBUG ERROR FATAL INFO WARN"
        if _args.log not in loglevels:  # pragma: nocover
            error('legal values for the -L parameter are:', loglevels)
        loglevel = getattr(logging, _args.log)
    else:
        loglevel = None

    logging.basicConfig(
        level=loglevel,
        format='%(filename)s:%(lineno)d: %(levelname)s: %(message)s'
    )

    if _args.version:  # pragma: nocover
        print("pydeps v" + __version__)
        sys.exit(0)

    return _p, _args, argv
408475
def create_args_parser():
    
    parser = argparse.ArgumentParser(
        description='Dialect-aware s-expression indenter', prog='yasi')
    parser.add_argument('files', help='List of files to be indented. '
                        'Will indent from standard input if no files are specified',
                        nargs='*')
    parser.add_argument(
        '-nc', '--no-compact', '--nc', dest='compact',
        help='Do not compact the code, just indent', action='store_false')
    parser.add_argument(
        '-nb', '--no-backup', '--nb', dest='backup', action='store_false',
        help='Do not create a backup file even if --backup-dir is specified ')
    parser.add_argument(
        '-nm', '--no-modify', '--nm', dest='modify',
        help='Do not modify the file', action='store_false')
    parser.add_argument(
        '--diff', '-diff', dest='output_diff',
        help='Prints unified diff of the initial and final result',
        action='store_true')
    parser.add_argument(
        '-nw', '--no-warning', '--nw', dest='warning',
        help='Do not display warnings', action='store_false')
    parser.add_argument(
        '-nr', '--no-rc', '--nr', dest='read_rc',
        help='Ignore any rc files in the current or home folder',
        action='store_false')
    parser.add_argument(
        '--no-output', '-no-output', dest='output',
        help='Suppress output of the indented code', action='store_false')
    parser.add_argument(
        '-c', '--color', '-color', dest='colour_diff',
        help='Display diff text in color', action='store_true')
    parser.add_argument(
        '-ne', '--no-exit', '--ne', dest='exit', action='store_false',
        help='Instructs the program not to exit when a warning is raised.')
    parser.add_argument(
        '-o', dest='output_file',
        help='Path/name of output file', type=str, default='')
    parser.add_argument(
        '--tab', '-tab', dest='tab_size',
        help='Indent with tabs using the specified tabwidth. A tab is assumed \
        equal to 4 spaces by default when expanding the tabs in the input file',
        type=int, default=-1)
    parser.add_argument(
        '--dialect', '-dialect',
        help='Use Scheme keywords', type=str, default='')
    parser.add_argument(
        '-v', '--version', action='version',
        help='Prints script version', version='yasi v%s' % __version__)
    parser.add_argument(
        '-suffix', '--suffix', dest='backup_suffix', help='Backup file suffix',
        type=str, default='.yasi.bak~')
    parser.add_argument(
        '-bd', '--backup-dir', '--bd', '-backup-dir',
        help='The directory where the backup file is to be written',
        type=str, default=os.getcwd())
    parser.add_argument(
        '-is', '--indent-size', '--is',
        help='The number of spaces per indent',
        type=int, default=2)
    parser.add_argument(
        '-di', '--default-indent', '--di',
        help='The indent level to be used in case a ' +
        "function's argument is in the next line. Vim uses 2, the most common being 1.",
        type=int, default=1)
    parser.add_argument(
        '-ic', '--indent-comments', '--ic',
        help='If true, comment lines will be indented possibly ' +
        'messing with any deliberate comment layout', action='store_true')
    parser.add_argument(
        '-uni', '--uniform', '-uniform', '--uni',
        help='Dictates whether the if-clause and else-clause of an if-like' +
        'block should have the same indent level.',
        action='store_true')
    return parser
605292
def parse_arguments(argv):
  
  parser = argparse.ArgumentParser(
      formatter_class=argparse.RawDescriptionHelpFormatter,
      description=textwrap.dedent("""\
          Runs analysis on structured data and produces auxiliary files for
          training. The output files can also be used by the Transform step
          to materialize TF.Examples files, which for some problems can speed up
          training.

          Description of input files
          --------------------------

          1) If using csv files, the --schema parameter must be the file path to
             a schema file. The format of this file must be a valid BigQuery
             schema file, which is a JSON file containing a list of dicts.
             Consider the example schema file below:

             [
                {"name": "column_name_1", "type": "integer"},
                {"name": "column_name_2", "type": "float"},
                {"name": "column_name_3", "type": "string"},
                {"name": "column_name_4", "type": "string"},
             ]

             Note that the column names in the csv file much match the order
             in the schema list. Also, we only support three BigQuery types (
             integer, float, and string).

             If instead of csv files, --bigquery is used, the schema file
             is not needed as this program will extract it from
             the table directly.

          2) --features is a file path to a file describing the
             transformations. Below is an example features file:

             {
                "column_name_1": {"transform": "scale"},
                "column_name_3": {"transform": "target"},
                "column_name_2": {"transform": "one_hot"},
                "new_feature_name": {"transform": "multi_hot", "source_column": "column_name_4"},
             }

             The format of the dict is `name`: `transform-dict` where the
             `name` is the name of the transformed feature. The `source_column`
             value lists what column in the input data is the source for this
             transformation. If `source_column` is missing, it is assumed the
             `name` is a source column and the transformed feature will have
             the same name as the input column.

             A list of supported `transform-dict`s for xgboost is below:

             {"transform": "identity"}: does nothing (for numerical columns).
             {"transform": "scale", "value": x}: scale a numerical column to
                [-a, a]. If value is missing, x defaults to 1.
             {"transform": "one_hot"}: makes a one-hot encoding of a string
                column.
             {"transform": "multi_hot", "separator": ' '}: makes a multi-hot
                encoding of a string column.
             {"transform": "image_to_vec", "checkpoint": "gs://b/o"}: From image
                gs url to embeddings. "checkpoint" is a inception v3 checkpoint.
                If absent, a default checkpoint is used.
             {"transform": "target"}: denotes what column is the target. If the
                schema type of this column is string, a one_hot encoding is
                automatically applied. If type is numerical, a identity transform
                is automatically applied.
  """))
  parser.add_argument('--cloud',
                      action='store_true',
                      help='Analysis will use cloud services.')
  parser.add_argument('--output',
                      metavar='DIR',
                      type=str,
                      required=True,
                      help='GCS or local folder')

  input_group = parser.add_argument_group(
      title='Data Source Parameters',
      description='schema is only needed if using --csv')

  # CSV input
  input_group.add_argument('--csv',
                           metavar='FILE',
                           type=str,
                           required=False,
                           action='append',
                           help='Input CSV absolute file paths. May contain a '
                                'file pattern.')
  input_group.add_argument('--schema',
                           metavar='FILE',
                           type=str,
                           required=False,
                           help='Schema file path. Only required if using csv files')

  # Bigquery input
  input_group.add_argument('--bigquery',
                           metavar='PROJECT_ID.DATASET.TABLE_NAME',
                           type=str,
                           required=False,
                           help=('Must be in the form project.dataset.table_name'))

  parser.add_argument('--features',
                      metavar='FILE',
                      type=str,
                      required=True,
                      help='Features file path')

  args = parser.parse_args(args=argv[1:])

  if args.cloud:
    if not args.output.startswith('gs://'):
      raise ValueError('--output must point to a location on GCS')
    if (args.csv and
       not all(x.startswith('gs://') for x in args.csv)):
      raise ValueError('--csv must point to a location on GCS')
    if args.schema and not args.schema.startswith('gs://'):
      raise ValueError('--schema must point to a location on GCS')

  if not args.cloud and args.bigquery:
    raise ValueError('--bigquery must be used with --cloud')

  if not ((args.bigquery and args.csv is None and
           args.schema is None) or
          (args.bigquery is None and args.csv and
           args.schema)):
    raise ValueError('either --csv and --schema must both'
                     ' be set or just --bigquery is set')

  return args
1153502
def _parse_args():
    """"""
    class HelpOnErrorArgParser(argparse.ArgumentParser):
        """Print help message as well when an error is raised."""
        def error(self, message):
            sys.stderr.write("Error: %s\n" % message)
            self.print_help()
            sys.exit(2)

    def validate(_file):
        """Validate if the given target argument is a valid file or a valid directory"""
        _file = abspath(_file)
        if not exists(_file):
            if not exists(dirname(_file)):
                # Argparse uses the ArgumentTypeError to give a rejection message like:
                # error: argument input: x does not exist
                raise argparse.ArgumentTypeError("{0} does not exist".format(_file))
        return _file

    def expand_cg_args(cg_args):
        """Separate clubbed flags in command line args for the generator.py

        Allows flags to be clubbed like, -ilt example.txt.
        """
        expanded = list()
        for item in cg_args:
            if len(item) < 3:
                # If at all a flag, must be single flag
                expanded.append(item)
                continue
            if item.startswith("-"):
                if not item.startswith("--"):
                    for flag in item[1:]:
                        expanded.append('-' + flag)
                    continue
            expanded.append(item)
        return expanded

    class AssignDefaultIgnore(argparse.Action):
        """If argument is specified but nothing provided, use pre-defined.

        nargs="*" doesn't allow const and default kwarg can't be used as we might not want to
        ignore as well.
        """
        def __call__(self, parser, args, values, option_string=None):
            if values is not None and not len(values):
                values = IGNORE_METHODS
            setattr(args, self.dest, values)

    try:
        indx = sys.argv.index('--')
        cg_args, sys.argv = sys.argv[1:indx], sys.argv[:1] + sys.argv[indx + 1:]
    except ValueError:
        cg_args = []

    cg_args = expand_cg_args(cg_args)  # allow -il type of usage
    parser = HelpOnErrorArgParser(description=DESCRIPTION)
    parser.add_argument(
        "-l", "--long", action='store_true', default=False,
        help="File reference of method in call graph is absolute, i.e. starts with ansible, "
             "otherwise just the basename if not __init__.py")
    parser.add_argument(
        "-t", "--target", nargs="?", type=validate, const=TARGET_FILE, default=TARGET_FILE,
        help="Filepath to write call graph, defaults to %(default)s")
    parser.add_argument(
        "-i", "--ignore", nargs='*', action=AssignDefaultIgnore,
        help="Methods to ignore while generating call graph")
    # TODO: Aloow classes that can be intercepted
    parser.usage = \
        parser.format_usage()[len("usage: "):].rstrip() + " -- <ansible-playbook options>\n"
    cg_args = parser.parse_args(cg_args)

    if not len(sys.argv[1:]):
        parser.print_help()
        sys.exit(2)

    return cg_args