python.trfArgClasses.trfArgParser Class Reference

Inheritance diagram for python.trfArgClasses.trfArgParser:

Collaboration diagram for python.trfArgClasses.trfArgParser:

Public Member Functions
	__init__ (self, *args, **kwargs)
	Subclassing argparse.
	add_argument (self, *args, **kwargs)
	getProdsysDesc (self)
	defineArgGroup (self, *args)
	Define an argparse argument group for the main parser to use.
	getHelpString (self, argument)
	Return the help string for a given argument.
	dumpArgs (self)
	Return a list of all arguments understood by this transform in prodsys style.
	allArgs (self)
	Getter for argument list.
	parse_args (self, args=None, namespace=None)
	Call argument_parser parse_args, then concatenate values.

Protected Member Functions
	_parse_list_helper (self, value)

Protected Attributes
dict	_helpString = {}
dict	_argClass = {}
dict	_argGroups = {}
dict	_argKeyGroups = {}
dict	_argAlias = {}

Detailed Description

Definition at line 2463 of file trfArgClasses.py.

Constructor & Destructor Documentation

__init__()

python.trfArgClasses.trfArgParser.__init__	(		self,
		*	args,
		**	kwargs )

Subclassing argparse.

Changed the defualt methods for add_arguments and parse_args. This is so that the help functions and the namespace object can be more useful.

Note

self._helpString. Is a dictionary with the where the key-value pairs are the argument name and the help text.

self._argClass. Is a dictionary so the 'type' of argument, i.e. the class that it uses can be extracted.

Definition at line 2470 of file trfArgClasses.py.

    def __init__(self, *args, **kwargs):
        self._helpString = {}
        self._argClass = {}
        self._argGroups = {}
        self._argKeyGroups = {}
        self._argAlias = {}
        super(trfArgParser, self).__init__(*args, **kwargs)
 

Member Function Documentation

_parse_list_helper()

python.trfArgClasses.trfArgParser._parse_list_helper ( self, value )

protected

Definition at line 2575 of file trfArgClasses.py.

    def _parse_list_helper(self, value):
        # We build on the value[0] instance as this contains the correct metadata
        # and object references for this instance (shallow copying can
        # mess up object references and deepcopy thows exceptions!)
        newValueObj = value[0]
        msg.debug('Started with: %s = %s', type(newValueObj), newValueObj)
        if isinstance(value[0], argSubstep):
            # Make sure you do not have a reference to the original value - this is a deeper copy
            newValues = dictSubstepMerge(value[0].value, {})
        elif isinstance(value[0], list):
            if len(value) == 1:
                return self._parse_list_helper(value[0])
            msg.debug('Handling a list of arguments for key')
            newValues = []
            for v in value:
                processedValueObj, processedValues = self._parse_list_helper(v)
                processedValueObj.value = processedValues
                newValues.append(processedValueObj)
            newValueObj = newValues
            return newValueObj, newValues
        elif isinstance(value[0].value, list):
            newValues = value[0].value
        elif isinstance(value[0].value, dict):
            newValues = value[0].value
        else:
            newValues = [value[0].value,]
        for valueObj in value[1:]:
            msg.debug('Value Object: %s = %s', type(valueObj), valueObj)
            if isinstance(value[0], argSubstep):
                # Special merger for lists attached to substeps
                newValues = dictSubstepMerge(newValues, valueObj.value)
            elif isinstance(valueObj.value, list):
                # General lists are concatenated
                newValues.extend(valueObj.value)
            elif isinstance(valueObj.value, dict):
                # General dictionaries are merged
                newValues.update(valueObj.value)
            else:
                newValues.append(valueObj.value)
        return newValueObj, newValues
 

add_argument()

python.trfArgClasses.trfArgParser.add_argument	(		self,
		*	args,
		**	kwargs )

Definition at line 2478 of file trfArgClasses.py.

    def add_argument(self, *args, **kwargs):
        argName = args[0].lstrip('-')
        msg.debug('Found arg name {0}'.format(argName))
 
        # Ban arguments with hyphens as they cause trouble in signature files and then
        # AMI tag definitions because of the auto-translation to underscores in argparse
        if '-' in argName:
            raise trfExceptions.TransformArgException(trfExit.nameToCode('TRF_ARG_ERROR'),
                                                      'Transform arguments may not use hyphens (use camelCase or underscore')
        
        # Prevent a crash if this argument already exists (there are valid use cases for 'grabbing' an
        # argument, so this is DEBUG, not WARNING)
        if argName in self._argClass:
            msg.debug('Double definition of argument {0} - ignored'.format(argName))
            return
        
        # if there is a help function defined for the argument then populate the helpString dict
        if 'help' in kwargs: 
            self._helpString[argName] = kwargs['help'] # if the help option is present for the argument then put it into the helpString dict key = argument name, value = help 
        else:
            self._helpString[argName] = None
        if 'action' in kwargs and 'factory' in dir(kwargs['action']):
            self._argClass[argName] = kwargs['action'].factory
        elif 'type' in kwargs:
            self._argClass[argName] = kwargs['type']
        else:
            self._argClass[argName] = None
 
        # Remove kwargs which are not understood by ArgumentParser.add_argument()
        strippedArgs = {}
        for arg in ('group',):
            if arg in kwargs:
                strippedArgs[arg] = kwargs.pop(arg)
 
        # Setup aliases
        if len(args) > 1:
            for i in range(1, len(args)):
                argAlias = args[i].lstrip('-')
                msg.debug('Adding an alias of {0}: {1}'.format(argName, argAlias))
                self._argAlias[argAlias] = argName
 
        # Optinally add an argument to an argparse argument group
        if 'group' in strippedArgs:
            if strippedArgs['group'] in self._argGroups:
                msg.debug('Adding argument to group {0}: ({1}; {2})'.format(strippedArgs['group'], args, kwargs))
                self._argGroups[strippedArgs['group']].add_argument(*args, **kwargs)
                self._argKeyGroups[argName] = strippedArgs['group']
            else:
                msg.warning('Argument group {0} not defined - adding argument to main parser'.format(strippedArgs['group']))
                msg.debug('Adding argument: ({0}; {1})'.format(args, kwargs))
                super(trfArgParser, self).add_argument(*args, **kwargs)
        else:
            msg.debug('Adding argument: ({0}; {1})'.format(args, kwargs))
            super(trfArgParser, self).add_argument(*args, **kwargs)
 

allArgs()

python.trfArgClasses.trfArgParser.allArgs

(

self

)

Getter for argument list.

Definition at line 2571 of file trfArgClasses.py.

    def allArgs(self):
        return list(self._helpString)
 

defineArgGroup()

python.trfArgClasses.trfArgParser.defineArgGroup	(		self,
		*	args )

Define an argparse argument group for the main parser to use.

Definition at line 2547 of file trfArgClasses.py.

    def defineArgGroup(self, *args):
        # Get an argparse group
        if args[0] in self._argGroups:
            msg.warning('Argument group %s already exists', args[0])
            return
        self._argGroups[args[0]] = self.add_argument_group(*args)
        

dumpArgs()

python.trfArgClasses.trfArgParser.dumpArgs

(

self

)

Return a list of all arguments understood by this transform in prodsys style.

Arguments which are irrelevant for production are removed and the '–' is added back on

Definition at line 2564 of file trfArgClasses.py.

    def dumpArgs(self):
        keyArray = [ '--' + str(key) for key in self._helpString if key not in ('h', 'verbose', 'loglevel', 'dumpargs', 'argdict') ]
        keyArray.sort()
        print('ListOfDefaultPositionalKeys={0}'.format(keyArray))
        

getHelpString()

python.trfArgClasses.trfArgParser.getHelpString	(		self,
			argument )

Return the help string for a given argument.

Definition at line 2555 of file trfArgClasses.py.

    def getHelpString(self, argument):
        try:
            return(self._helpString[argument])
        except KeyError:
            raise trfExceptions.TransformArgException(trfExit.nameToCode('TRF_KEY_ERROR'), 'no help string available for argument %s' %argument)
        return None
 

getProdsysDesc()

python.trfArgClasses.trfArgParser.getProdsysDesc

(

self

)

Definition at line 2534 of file trfArgClasses.py.

    def getProdsysDesc(self):
        desc = {}
        for name, argClass in self._argClass.items():
            msg.debug('Detected the local variable {0}'.format(name))
            if argClass is not None:
                desc[name] = argClass().prodsysDescription
                if name in self._helpString:
                    desc[name].update({'help': self._helpString[name]})
                if name in self._argKeyGroups:
                    desc[name].update({'group':self._argKeyGroups[name]})
        return desc
            

parse_args()

python.trfArgClasses.trfArgParser.parse_args	(		self,
			args = None,
			namespace = None )

Call argument_parser parse_args, then concatenate values.

Sets-up the standard argparse namespace, then use a special treatment for lists (arising from nargs='+'), where values are appropriately concatenated and a single object is returned

Returns

argument_parser namespace object

Definition at line 2621 of file trfArgClasses.py.

    def parse_args(self, args = None, namespace = None):
        if namespace:
            super(trfArgParser, self).parse_args(args = args, namespace = namespace)
        else:
            namespace = super(trfArgParser, self).parse_args(args = args)
        for k, v in namespace.__dict__.items():
            msg.debug('Treating key %s (%s)', k, v)
            if isinstance(v, list):
                newValueObj, newValues = self._parse_list_helper(v)
                if not isinstance(newValueObj, list):
                    newValueObj.value = newValues
                namespace.__dict__[k] = newValueObj
                msg.debug('Set to %s', newValues)
 
        return namespace
 
 

Member Data Documentation

_argAlias

dict python.trfArgClasses.trfArgParser._argAlias = {}

protected

Definition at line 2475 of file trfArgClasses.py.

_argClass

dict python.trfArgClasses.trfArgParser._argClass = {}

protected

Definition at line 2472 of file trfArgClasses.py.

_argGroups

dict python.trfArgClasses.trfArgParser._argGroups = {}

protected

Definition at line 2473 of file trfArgClasses.py.

_argKeyGroups

dict python.trfArgClasses.trfArgParser._argKeyGroups = {}

protected

Definition at line 2474 of file trfArgClasses.py.

_helpString

python.trfArgClasses.trfArgParser._helpString = {}

protected

Definition at line 2471 of file trfArgClasses.py.

---

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

• trfArgClasses.py