Inheritance diagram for lsst.ctrl.pool.parallel.BatchArgumentParser:

Public Member Functions
def	__init__ (self, parent=None, args, *kwargs)

def	parse_args (self, config=None, args=None, namespace=None, **kwargs)

def	makeBatch (self, args)

def	format_help (self)

def	format_usage (self)

Detailed Description

An argument parser to get relevant parameters for batch submission

We want to be able to display the help for a 'parent' ArgumentParser
along with the batch-specific options we introduce in this class, but
we don't want to swallow the parent (i.e., ArgumentParser(parents=[parent]))
because we want to save the list of arguments that this particular
BatchArgumentParser doesn't parse, so they can be passed on to a different
program (though we also want to parse them to check that they can be parsed).

Definition at line 298 of file parallel.py.

Constructor & Destructor Documentation

◆ init()

def lsst.ctrl.pool.parallel.BatchArgumentParser.__init__	(		self,
			parent = `None`,
		*	args,
		**	kwargs
	)

Definition at line 309 of file parallel.py.

     def __init__(self, parent=None, *args, **kwargs):
         super(BatchArgumentParser, self).__init__(*args, **kwargs)
         self._parent = parent
         group = self.add_argument_group("Batch submission options")
         group.add_argument("--queue", help="Queue name")
         group.add_argument("--job", help="Job name")
         group.add_argument("--nodes", type=int, default=0, help="Number of nodes")
         group.add_argument("--procs", type=int, default=0, help="Number of processors per node")
         group.add_argument("--cores", type=int, default=0, help="Number of cores (Slurm/SMP only)")
         group.add_argument("--time", type=float, default=0,
                            help="Expected execution time per element (sec)")
         group.add_argument("--walltime", type=float, default=0,
                            help="Expected total execution walltime (sec); overrides cores & time")
         group.add_argument("--batch-type", dest="batchType", choices=list(BATCH_TYPES.keys()), default="smp",
                            help="Batch system to use")
         group.add_argument("--batch-verbose", dest="batchVerbose", action="store_true", default=False,
                            help=("Enable verbose output in batch script "
                                  "(including system environment information at batch start)?"))
         group.add_argument("--batch-output", dest="batchOutput", help="Output directory")
         group.add_argument("--batch-submit", dest="batchSubmit", help="Batch submission command-line flags")
         group.add_argument("--batch-options", dest="batchOptions", help="Header options for batch script")
         group.add_argument("--batch-profile", dest="batchProfile", action="store_true", default=False,
                            help="Enable profiling on batch job?")
         group.add_argument("--batch-stats", dest="batchStats", action="store_true", default=False,
                            help="Print process stats on completion (Linux only)?")
         group.add_argument("--dry-run", dest="dryrun", default=False, action="store_true",
                            help="Dry run?")
         group.add_argument("--do-exec", dest="doExec", default=False, action="store_true",
                            help="Exec script instead of submit to batch system?")
         group.add_argument("--mpiexec", default="", help="mpiexec options")
  

Member Function Documentation

◆ format_help()

def lsst.ctrl.pool.parallel.BatchArgumentParser.format_help ( self )

Definition at line 378 of file parallel.py.

     def format_help(self):
         text = """This is a script for queue submission of a wrapped script.
  
 Use this program name and ignore that for the wrapped script (it will be
 passed on to the batch system).  Arguments for *both* this wrapper script or the
 wrapped script are valid (if it is required for the wrapped script, it
 is required for the wrapper as well).
  
 *** Batch system submission wrapper:
  
 """
         text += super(BatchArgumentParser, self).format_help()
         if self._parent is not None:
             text += """
  
 *** Wrapped script:
  
 """
             text += self._parent.format_help()
         return text
  

◆ format_usage()

def lsst.ctrl.pool.parallel.BatchArgumentParser.format_usage ( self )

Definition at line 399 of file parallel.py.

     def format_usage(self):
         if self._parent is not None:
             prog = self._parent.prog
             self._parent.prog = self.prog
             usage = self._parent.format_usage()
             self._parent.prog = prog
             return usage
         return super(BatchArgumentParser, self).format_usage()
  
  

◆ makeBatch()

def lsst.ctrl.pool.parallel.BatchArgumentParser.makeBatch	(	self,
		args
	)

Create a Batch object from the command-line arguments

Definition at line 353 of file parallel.py.

     def makeBatch(self, args):
         """Create a Batch object from the command-line arguments"""
         # argMapping is a dict that maps Batch init kwarg names to parsed arguments attribute *names*
         argMapping = {'outputDir': 'batchOutput',
                       'numNodes': 'nodes',
                       'numProcsPerNode': 'procs',
                       'numCores': 'cores',
                       'walltime': 'time',
                       'queue': 'queue',
                       'jobName': 'job',
                       'dryrun': 'dryrun',
                       'doExec': 'doExec',
                       'mpiexec': 'mpiexec',
                       'submit': 'batchSubmit',
                       'options': 'batchOptions',
                       'verbose': 'batchVerbose',
                       }
  
         if BATCH_TYPES[args.batchType] is None:
             return None
  
         # kwargs is a dict that maps Batch init kwarg names to parsed arguments attribute *values*
         kwargs = {k: getattr(args, v) for k, v in argMapping.items()}
         return BATCH_TYPES[args.batchType](**kwargs)
  

◆ parse_args()

def lsst.ctrl.pool.parallel.BatchArgumentParser.parse_args	(		self,
			config = `None`,
			args = `None`,
			namespace = `None`,
		**	kwargs
	)

Definition at line 340 of file parallel.py.

     def parse_args(self, config=None, args=None, namespace=None, **kwargs):
         args, leftover = super(BatchArgumentParser, self).parse_known_args(args=args, namespace=namespace)
         args.parent = None
         args.leftover = None
         if len(leftover) > 0:
             # Save any leftovers for the parent
             if self._parent is None:
                 self.error("Unrecognised arguments: %s" % leftover)
             args.parent = self._parent.parse_args(config, args=leftover, **kwargs)
             args.leftover = leftover
         args.batch = self.makeBatch(args)
         return args
  

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/ctrl_pool/22.0.1-2-g92698f7+9f079a9461/python/lsst/ctrl/pool/parallel.py

Public Member Functions