VarParsing.VarParsing Class Reference

Inheritance diagram for VarParsing.VarParsing:

Public Member Functions
def	__getattr__ (self, name, noTags=False)
def	__init__ (self, args)
def	__setattr__ (self, name, value, extras)
def	__str__ (self)
def	clearList (self, name)
def	has_key (self, key)
def	help (self)
def	loadFromFile (self, name, filename)
def	parseArguments (self)
def	register (self, name, default="", mult=multiplicity.singleton, mytype=varType.int, info="", kwargs)
def	setDefault (self, name, args)
def	setNoCommaSplit (self, name, value=True)
def	setNoDefaultClear (self, name, value=True)
def	setType (self, name, mytype)
def	setupTags (self, kwargs)

Public Attributes
	inputFiles
	Post-loading processing #. More...

Static Public Attributes
	commaRE
	falseRE
	multiplicity
	trueRE
	varType

Private Member Functions
def	_convert (self, name, inputVal)
def	_withTags (self, name)

Private Attributes
	_beenSet
	_currentlyParsing
	_info
	_lists
	_maxLength
	_noCommaSplit
	_noDefaultClear
	_register
	_setDuringParsing
	_singletons
	_tagOrder
	_tags
	_types

Detailed Description

Infrastructure to parse variable definitions passed to cmsRun
configuration scripts

Definition at line 9 of file VarParsing.py.

Constructor & Destructor Documentation

__init__()

def VarParsing.VarParsing.__init__	(		self,
			args
	)

Class initializer

Definition at line 21 of file VarParsing.py.

    def __init__ (self, *args):
        """Class initializer"""
        # Set everything up first
        self._singletons       = {}
        self._lists            = {}
        self._register         = {}
        self._beenSet          = {}
        self._info             = {}
        self._types            = {}
        self._maxLength        = 0
        self._tags             = {}
        self._tagOrder         = []
        self._noCommaSplit     = {}
        self._noDefaultClear   = {}
        self._setDuringParsing = {}
        self._currentlyParsing = False
        # now play with the rest
        for arg in args:
            lower = arg.lower()
            if lower == 'python':
                self.register ('storePrepend',
                               '',
                               VarParsing.multiplicity.singleton,
                               VarParsing.varType.string,
                               "Prepend location of files starting "
                               "with '/store'")
                # Don't continue because we want to process the next
                # piece, too.
            if lower == 'analysis' or lower == 'python':
                # Optionos for cmsRun or FWLite.Python
                self.register ('maxEvents',
                               -1,
                               VarParsing.multiplicity.singleton,
                               VarParsing.varType.int,
                               "Number of events to process (-1 for all)")
                self.register ('totalSections',
                               0,
                               VarParsing.multiplicity.singleton,
                               VarParsing.varType.int,
                               "Total number of sections")
                self.register ('section',
                               0,
                               VarParsing.multiplicity.singleton,
                               VarParsing.varType.int,
                               "This section (from 1..totalSections inclusive)")
                self.register ('inputFiles',
                               '',
                               VarParsing.multiplicity.list,
                               VarParsing.varType.string,
                               "Files to process")
                self.register ('secondaryInputFiles',
                               '',
                               VarParsing.multiplicity.list,
                               VarParsing.varType.string,
                               "Second group of files to process (if needed)")
                self.register ('filePrepend',
                               '',
                               VarParsing.multiplicity.singleton,
                               VarParsing.varType.string,
                               "String to prepend location of all files")
                self.register ('outputFile',
                               'output.root',
                               VarParsing.multiplicity.singleton,
                               VarParsing.varType.tagString,
                               "Name of output file (if needed)")
                self.register ('secondaryOutputFile',
                               '',
                               VarParsing.multiplicity.singleton,
                               VarParsing.varType.tagString,
                               "Name of second output file (if needed)")
                self.register ('tag',
                               '',
                               VarParsing.multiplicity.singleton,
                               VarParsing.varType.string,
                               "tag to add to output filename")
                self.setupTags (tag = 'numEvent%d',
                                ifCond = 'maxEvents > 0',
                                tagArg = 'maxEvents')
                self.setupTags (tag = '%s',
                                ifCond = 'tag',
                                tagArg = 'tag')
                continue
            # old, depricated, but here for compatibility of older code
            if lower == "standard":
                # load in old standard arguments and defaults
                self.register ('maxEvents',
                               -1,
                               VarParsing.multiplicity.singleton,
                               VarParsing.varType.int,
                               "Number of events to process (-1 for all)")
                self.register ('files',
                               '',
                               VarParsing.multiplicity.list,
                               VarParsing.varType.string,
                               "Files to process")
                self.register ('secondaryFiles',
                               '',
                               VarParsing.multiplicity.list,
                               VarParsing.varType.string,
                               "Second group of files to process (if needed)")
                self.register ('output',
                               'output.root',
                               VarParsing.multiplicity.singleton,
                               VarParsing.varType.tagString,
                               "Name of output file (if needed)")
                self.register ('secondaryOutput',
                               '',
                               VarParsing.multiplicity.singleton,
                               VarParsing.varType.tagString,
                               "Name of second output file (if needed)")
                self.setupTags (tag = 'numEvent%d',
                                ifCond = 'maxEvents > 0',
                                tagArg = 'maxEvents')
                continue
            # if we're still here, then we've got a rogue arument
            print("Error: VarParsing.__init__ doesn't understand '%s'" \
                  % arg)
            raise RuntimeError("Failed to create VarParsing object")

Member Function Documentation

__getattr__()

def VarParsing.VarParsing.__getattr__	(		self,
			name,
			noTags = False
	)

Lets user get the info they want with obj.name

Definition at line 599 of file VarParsing.py.

References VarParsing.VarParsing._lists, VarParsing.VarParsing._register, VarParsing.VarParsing._singletons, VarParsing.VarParsing._types, TreeCrawler.mymf._types, hcaldqm::quantity::EventType._types, VarParsing.VarParsing._withTags(), and print().

Referenced by VarParsing.VarParsing.setType().

    def __getattr__ (self, name, noTags = False):
        """Lets user get the info they want with obj.name"""
        if name.startswith ("_"):
            # internal use
            return object.__getattribute__ (self, name)
        else:
            # user variable
            if name not in self._register:
                print("Error:  '%s' not already registered." \
                      % name)
                raise RuntimeError("Unknown variable")
            if VarParsing.multiplicity.singleton == self._register[name]:
                if VarParsing.varType.tagString == self._types[name] \
                       and not noTags:
                    return self._withTags (name)
                else:
                    return self._singletons[name]
            else:
                return self._lists[name]
 

__setattr__()

def VarParsing.VarParsing.__setattr__	(		self,
			name,
			value,
			extras
	)

Lets me set internal values, or uses setDefault

Definition at line 589 of file VarParsing.py.

References HcalItemCollById< Item >.setDefault(), and VarParsing.VarParsing.setDefault().

Referenced by GenObject.GenObject.setValue().

    def __setattr__ (self, name, value, *extras):
        """Lets me set internal values, or uses setDefault"""
        if not name.startswith ("_"):
            mylist = list (extras)
            mylist.insert (0, value)
            self.setDefault (name, *mylist)
        else:
            object.__setattr__ (self, name, value)

__str__()

def VarParsing.VarParsing.__str__

(

self

)

String form of self

Definition at line 554 of file VarParsing.py.

References VarParsing.VarParsing._info, VarParsing.VarParsing._lists, VarParsing.VarParsing._maxLength, VarParsing.VarParsing._singletons, and mps_monitormerge.items.

    def __str__ (self):
        """String form of self"""
        maxLen = min (self._maxLength, 20)
        form     = "  %%-%ds: %%s" % maxLen
        formInfo = "  %%%ds  - %%s" % (maxLen - 2)
        formItem = "  %%%ds    %%s" % (maxLen - 1)
        retval = ""
        if len (self._singletons):
            retval = retval + "Singletons:\n"
        for varName, value in sorted (self._singletons.items()):
            retval = retval + form % (varName, value) + "\n";
            if self._info.get(varName):
                retval = retval + formInfo % ('', self._info[varName]) + "\n"
        if len (self._singletons):
            retval = retval +  "Lists:\n"
        for varName, value in sorted (self._lists.items()):
            stringValue = "%s" % value
            if len (stringValue) < 76 - maxLen:
                retval = retval + form % (varName, value) + "\n"
            else:
                varLength = len (value)
                for index, item in enumerate (value):
                    if index == 0:
                        retval = retval + form % (varName, "['" + item)
                    else:
                        retval = retval + formItem % ('',"'" + item)
                    if index == varLength - 1:
                        retval = retval + "' ]\n"
                    else:
                        retval = retval + "',\n"
            if self._info.get(varName):
                retval = retval + formInfo % ('', self._info[varName]) + "\n"
        return retval

_convert()

def VarParsing.VarParsing._convert (   self,   name,   inputVal  )

private

Converts inputVal to the type required by name

Definition at line 503 of file VarParsing.py.

References VarParsing.VarParsing._types, TreeCrawler.mymf._types, and hcaldqm::quantity::EventType._types.

Referenced by VarParsing.VarParsing.loadFromFile(), and VarParsing.VarParsing.setDefault().

    def _convert (self, name, inputVal):
        """Converts inputVal to the type required by name"""
        inputVal = str (inputVal)
        if self._types[name] == VarParsing.varType.bool:
            if VarParsing.trueRE.match (inputVal) or '1' == inputVal:
                return True
            elif VarParsing.falseRE.match (inputVal) or '0' == inputVal:
                return False
            # if we're still here, then we don't have 'true' or 'false'
            raise RuntimeError("Unknown bool value '%s'.  Must be 'true' or 'false'" % inputVal)
        if self._types[name] == VarParsing.varType.string or \
           self._types[name] == VarParsing.varType.tagString:
            return inputVal
        elif self._types[name] == VarParsing.varType.int:
            return int (inputVal, 0)
        elif self._types[name] == VarParsing.varType.float:
            return float (inputVal)
        else:
            raise RuntimeError("Unknown varType")
        

_withTags()

def VarParsing.VarParsing._withTags (   self,   name  )

private

Definition at line 524 of file VarParsing.py.

References VarParsing.VarParsing._register, VarParsing.VarParsing._singletons, VarParsing.VarParsing._tagOrder, VarParsing.VarParsing._tags, and print().

Referenced by VarParsing.VarParsing.__getattr__().

    def _withTags (self, name):
        if name not in self._register:
            print("Error:  '%s' not registered." \
                  % name)
            raise RuntimeError("Unknown variable")
        if self._register[name] == VarParsing.multiplicity.list:
            print("Error: '%s' is a list" % name)
            raise RuntimeError("withTags() only works on singletons")
        retval = self._singletons[name]
        if retval.endswith ('.root'):
            retval, garbage = os.path.splitext (retval)
        reverseOrder = self._tagOrder
        reverseOrder.reverse()
        for tag in reverseOrder:
            tagDict = self._tags[tag]
            ifCond = tagDict['ifCond']
            if ifCond.count('%'):
                pass
            else:
                ifCond = "self." + ifCond
            boolValue = eval (ifCond)
            tagArg = tagDict.get ('tagArg')
            if tagArg:
                evalString = "'%s' %% self.%s" % (tag, tagArg)
                tag = eval (evalString)
            if boolValue:
                retval = retval + "_" + tag        
        return retval + ".root"
            

clearList()

def VarParsing.VarParsing.clearList	(		self,
			name
	)

Empties all entries from list

Definition at line 302 of file VarParsing.py.

References VarParsing.VarParsing._lists, VarParsing.VarParsing._register, and print().

Referenced by VarParsing.VarParsing.parseArguments(), and VarParsing.VarParsing.setDefault().

    def clearList (self, name):
        """Empties all entries from list"""
        if name not in self._register:
            print("Error:  '%s' not registered." \
                  % name)
            raise RuntimeError("Unknown variable")
        if self._register[name] != VarParsing.multiplicity.list:
            print("Error: '%s' is not a list" % name)
            raise RuntimeError("Faulty 'clear' command")
        # if we're still here, do what we came to do
        self._lists[name] = []

has_key()

def VarParsing.VarParsing.has_key	(		self,
			key
	)

Returns true if a key is registered

Definition at line 433 of file VarParsing.py.

References VarParsing.VarParsing._register.

    def has_key (self, key):
        """Returns true if a key is registered"""
        return key in self._register

help()

def VarParsing.VarParsing.help

(

self

)

Prints out help information and exits

Definition at line 362 of file VarParsing.py.

References print(), and VarParsing.VarParsing.register().

    def help (self):
        """Prints out help information and exits"""
        print(self)
        print("""Options:
        help           : This screen
        multipleAssign : Allows singletons to have multiple assigments
        print          : Prints out current values
        XXX_clear      : Clears list named 'XXX'
        """)    
        sys.exit (0)

loadFromFile()

def VarParsing.VarParsing.loadFromFile	(		self,
			name,
			filename
	)

Loads a list from file

Definition at line 340 of file VarParsing.py.

References VarParsing.VarParsing._convert(), VarParsing.VarParsing._lists, VarParsing.VarParsing._register, mps_setup.append, and print().

Referenced by VarParsing.VarParsing.parseArguments().

    def loadFromFile (self, name, filename):
        """Loads a list from file"""
        if name not in self._register:
            print("Error:  '%s' not registered." \
                  % name)
            raise RuntimeError("Unknown variable")
        if self._register[name] != VarParsing.multiplicity.list:
            print("Error: '%s' is not a list" % name)
            raise RuntimeError("'load' only works for lists")
        filename = os.path.expanduser (filename)
        if not os.path.exists (filename):
            print("Error: '%s' file does not exist.")
            raise RuntimeError("Bad filename")
        source = open (filename, 'r')                for line in source.readlines():
            line = re.sub (r'#.+$', '', line) # remove comment characters
            line = line.strip()
            if len (line):
                self._lists[name].append( self._convert (name, line ) )
        source.close()

parseArguments()

def VarParsing.VarParsing.parseArguments

(

self

)

Parses command line arguments.  Parsing starts just after
the name of the configuration script.  Parsing will fail if
there is not 'xxxx.py'

Definition at line 165 of file VarParsing.py.

References VarParsing.VarParsing._beenSet, VarParsing.VarParsing._currentlyParsing, VarParsing.VarParsing._register, VarParsing.VarParsing.clearList(), sistrip::EnsembleCalibrationLA.inputFiles, sistrip::MeasureLA.inputFiles, VarParsing.VarParsing.inputFiles, cms::SiPixelCondObjBuilder.loadFromFile(), cms::SiPixelCondObjOfflineBuilder.loadFromFile(), cms::SiPixelCondObjForHLTBuilder.loadFromFile(), VarParsing.VarParsing.loadFromFile(), print(), HcalZDCDetId.section(), edm::DocFormatHelper.section(), HcalCastorDetId.section(), HcalItemCollById< Item >.setDefault(), and VarParsing.VarParsing.setDefault().

    def parseArguments (self):
        """Parses command line arguments.  Parsing starts just after
        the name of the configuration script.  Parsing will fail if
        there is not 'xxxx.py'"""
        self._currentlyParsing = True
        foundPy      = False
        printStatus  = False
        help         = False
        singleAssign = True 
        for arg in sys.argv:
            if not foundPy and arg.endswith ('.py'):
                foundPy = True
                continue
            if not foundPy:
                continue
            # If we're here, then we can parse to our hearts content.
            # So, is this a command or a declaration?
            if arg.count('='):
                # declaration
                name, value = arg.split ('=', 1)
                if name.count('_'):
                    # name with command
                    name, command = name.split ('_', 1)
                    command = command.lower()
                    if command == 'load':
                        self.loadFromFile (name, value)
                        continue
                    if command == 'clear':
                        self.clearList (name)
                        continue
                    # If we're here, then I don't recognize this command
                    print("Unknown command '%s' in '%s_%s" % \
                          (command, name, command))
                    raise RuntimeError("Illegal parsing command")
                else:
                    # just a name and value
                    if name not in self._register:
                        print("Error:  '%s' not registered." \
                              % name)
                        raise RuntimeError("Unknown variable")
                    if VarParsing.multiplicity.singleton == \
                           self._register[name]:
                        # singleton
                        if self._beenSet.get (name) and singleAssign:
                            print("Variable '%s' assigned multiple times. Use" \
                                  , "'multipleAssign' command to avoid")
                            raise RuntimeError("Multiple assignment")
                        self._beenSet[name] = True
                        self.setDefault (name, value)
                    else:
                        # list
                        self.setDefault (name, value)
            else:
                # commands
                if arg.count('_'):
                    # name modifier
                    name, command = arg.split ('_', 1)
                    command = command.lower()
                    if name not in self._register:
                        print("Error:  '%s' not registered." \
                              % name)
                        raise RuntimeError("Unknown variable")
                    if command == 'clear':
                        self.clearList (name)
                        continue
                    # if we're still here, complain that we don't
                    # understand this command:
                    print("Do not understand '%s' in '%s'" % (command, arg))
                    raise RuntimeError("Unknown command")
                else:
                    # simple command
                    command = arg.lower()
                    if command == 'help' or command == '--help':
                        help = True
                    elif command == 'print' or command == '--print':
                        printStatus = True
                    elif command == 'noprint' or command == '--noprint':
                        printStatus = False
                    else:
                        # We don't understand this command
                        print("Do not understand command '%s'" % (arg))
                        raise RuntimeError("Unknown command")
            # else if declaration
        
        if 'totalSections' in self._register and \
           'section' in self._register and \
           'inputFiles' in self._register and \
           self.totalSections and self.section:
            # copy list
            oldInputFiles = self.inputFiles
            # clear list
            self.clearList ('inputFiles')
            # used old list to make list
            self.inputFiles = sectionNofTotal (oldInputFiles,
                                               self.section,
                                               self.totalSections)
        # storePrepend
        if 'storePrepend' in self._register and \
           'inputFiles' in self._register and \
           self.storePrepend:
            storeRE = re.compile (r'^/store/')
            newFileList = []
            for filename in self.inputFiles:
                if storeRE.match (filename):
                    filename = self.storePrepend + filename
                newFileList.append (filename)
            # clear old list
            self.clearList ('inputFiles')
            # set new list as list
            self.inputFiles = newFileList
        # filePrepend
        if 'filePrepend' in self._register and \
           'inputFiles' in self._register and \
           self.filePrepend:
            newFileList = []
            for filename in self.inputFiles:
                filename = self.filePrepend + filename
                newFileList.append (filename)
            # clear old list
            self.clearList ('inputFiles')
            # set new list as list
            self.inputFiles = newFileList
        # make sure found the py file
        if not foundPy:
            print("VarParsing.parseArguments() Failure: No configuration " + \
                  "file found ending in .py.")
            raise RuntimeError("Invalid configuration ending")
        if help:
            self.help()
        if printStatus:
            print(self)
        self._currentlyParsing = False

register()

def VarParsing.VarParsing.register	(		self,
			name,
			default = "",
			mult = multiplicity.singleton,
			mytype = varType.int,
			info = "",
			kwargs
	)

Register a variable

Definition at line 379 of file VarParsing.py.

References VarParsing.VarParsing._beenSet, VarParsing.VarParsing._info, VarParsing.VarParsing._lists, VarParsing.VarParsing._maxLength, VarParsing.VarParsing._noCommaSplit, VarParsing.VarParsing._noDefaultClear, VarParsing.VarParsing._register, VarParsing.VarParsing._singletons, VarParsing.VarParsing._types, TreeCrawler.mymf._types, hcaldqm::quantity::EventType._types, nano_mu_local_reco_cff.bool, and print().

Referenced by counter.Counter.__add__(), and VarParsing.VarParsing.help().

                  **kwargs):
        """Register a variable"""
        # is type ok?
        if not VarParsing.multiplicity.isValidValue (mult):
            print("Error: VarParsing.register() must use ",\
                  "VarParsing.multiplicity.")
            raise RuntimeError("Improper 'mult' value")
        if not VarParsing.varType.isValidValue (mytype):
            print("Error: VarParsing.register() must use ",\
                  "VarParsing.varType.")
            raise RuntimeError("Improper 'type' value %s" % mytype)
        if VarParsing.multiplicity.list == mult and \
           VarParsing.varType.tagString == mytype:
            print("Error: 'tagString' can only be used with 'singleton'")
            raise RuntimeError("Improper registration")
        # is the name ok
        if name.count ("_"):
            print("Error: Name can not contain '_': %s" % name)
            raise RuntimeError("Improper 'name'")
        # has this been registered before?
        if name in self._register:
            # Uh oh
            print("Error: You can not register a name twice, '%s'" \
                  % name)
            raise RuntimeError("Attempt to re-register variable")
        self._register[name] = mult
        self._beenSet[name]  = False
        self._info[name]     = info
        self._types[name]    = mytype
        if len (name) > self._maxLength:
            self._maxLength = len (name)
        if VarParsing.multiplicity.singleton == mult:
            self._singletons[name] = default
        else:
            self._lists[name] = []
            # if it's a list, we only want to use the default if it
            # does exist.
            if len (default):
                self._lists[name].append (default)
        
        if kwargs.get ('noCommaSplit'):
            self._noCommaSplit[name] = bool( kwargs['noCommaSplit'] )
            del kwargs['noCommaSplit']
        if kwargs.get ('noDefaultClear'):
            self._noDefaultClear[name] = bool( kwargs['noDefaultClear'] )
            del kwargs['noDefaultClear']
        if len (kwargs):
            raise RuntimeError("register() Unknown arguments %s" % kwargs)

setDefault()

def VarParsing.VarParsing.setDefault	(		self,
			name,
			args
	)

Used to set or change the default of an already registered
name

Definition at line 449 of file VarParsing.py.

References VarParsing.VarParsing._convert(), VarParsing.VarParsing._currentlyParsing, VarParsing.VarParsing._lists, VarParsing.VarParsing._noCommaSplit, VarParsing.VarParsing._noDefaultClear, VarParsing.VarParsing._register, VarParsing.VarParsing._setDuringParsing, VarParsing.VarParsing._singletons, mps_setup.append, VarParsing.VarParsing.clearList(), and print().

Referenced by VarParsing.VarParsing.__setattr__(), VarParsing.VarParsing.parseArguments(), and VarParsing.VarParsing.setType().

    def setDefault (self, name, *args):
        """Used to set or change the default of an already registered
        name"""
        # has this been registered?
        if name not in self._register:
            print("Error: VarParsing.setDefault '%s' not already registered." \
                  % name)
            raise RuntimeError("setDefault without registration")
        if VarParsing.multiplicity.singleton == self._register[name]:
            # make sure we only have one value
            if len (args) != 1:
                print("Error: VarParsing.setDefault needs exactly 1 ",\
                      "value for '%s'" % name)
                raise RuntimeError("setDefault args problem")
            self._singletons[name] = self._convert (name, args[0])
        else:
            # If:
            #   - We have a list (which we do)
            #   - We are now processing command line parsing
            #   - It has not yet been set after parsing
            #   - We have not explicitly asked for it to be NOT cleared
            # Then:
            #   - We clear the list
            if self._currentlyParsing and \
               not self._setDuringParsing.get(name) and \
               not self._noDefaultClear.get(name):
                # All four conditions have been satisfied, so let's go
                # ahead and clear this.
                self.clearList (name)
            # IF we are currently parsing, then tell people I've set
            # this:
            if self._currentlyParsing:
                self._setDuringParsing[name] = True
            # if args is a tuple and it only has one entry, get rid of
            # the first level of tupleness:
            if isinstance (args, tuple) and len (args) == 1:
                args = args[0]
            # is this still a tuple
            if isinstance (args, tuple):
                mylist = list (args)
            elif isinstance (args, list):
                mylist = args
            else:
                mylist = []
                mylist.append (args)
            if not self._noCommaSplit.get (name):
                oldList = mylist
                mylist = []
                for item in oldList:
                    mylist.extend( VarParsing.commaRE.split( item ) )
            for item in mylist:
                self._lists[name].append( self._convert (name, item ) )

setNoCommaSplit()

def VarParsing.VarParsing.setNoCommaSplit	(		self,
			name,
			value = True
	)

Tells lists to not split up values by commas.

Definition at line 328 of file VarParsing.py.

References VarParsing.VarParsing._noCommaSplit, VarParsing.VarParsing._register, and print().

    def setNoCommaSplit (self, name, value=True):
        """Tells lists to not split up values by commas."""
        if name not in self._register:
            print("Error:  '%s' not registered." \
                  % name)
            raise RuntimeError("Unknown variable")
        if self._register[name] != VarParsing.multiplicity.list:
            print("Error: '%s' is not a list" % name)
            raise RuntimeError("Faulty 'setNoCommaSplit' command")
        self._noCommaSplit[name] = bool (value)

setNoDefaultClear()

def VarParsing.VarParsing.setNoDefaultClear	(		self,
			name,
			value = True
	)

Tells lists to not clear default list values when set from
command line.

Definition at line 315 of file VarParsing.py.

References VarParsing.VarParsing._noDefaultClear, VarParsing.VarParsing._register, and print().

    def setNoDefaultClear (self, name, value=True):
        """Tells lists to not clear default list values when set from
        command line."""
        if name not in self._register:
            print("Error:  '%s' not registered." \
                  % name)
            raise RuntimeError("Unknown variable")
        if self._register[name] != VarParsing.multiplicity.list:
            print("Error: '%s' is not a list" % name)
            raise RuntimeError("Faulty 'setNoDefaultClear' command")
        self._noDefaultClear[name] = bool (value)

setType()

def VarParsing.VarParsing.setType	(		self,
			name,
			mytype
	)

Change the type of 'name' to 'mytype'

Definition at line 438 of file VarParsing.py.

References Types._Untracked.__getattr__(), Types._ProxyParameter.__getattr__(), Types._ProxyParameterFactory.__getattr__(), VarParsing.VarParsing.__getattr__(), Config.FilteredStream.__getattr__(), Config.ProcessForProcessAccelerator.__getattr__(), VarParsing.VarParsing._types, TreeCrawler.mymf._types, hcaldqm::quantity::EventType._types, print(), HcalItemCollById< Item >.setDefault(), and VarParsing.VarParsing.setDefault().

    def setType (self, name, mytype):
        """Change the type of 'name' to 'mytype'"""
        if not VarParsing.varType.isValidValue (mytype):
            print("Error: VarParsing.setType() must use ",\
                  "VarParsing.varType.")
            raise RuntimeError("Improper 'type' value")
        oldVal = self.__getattr__ (name, noTags = True)
        self._types[name] = mytype
        self.setDefault (name, oldVal)
        

setupTags()

def VarParsing.VarParsing.setupTags	(		self,
			kwargs
	)

Sets up information for tags for output names

Definition at line 141 of file VarParsing.py.

References VarParsing.VarParsing._tagOrder, VarParsing.VarParsing._tags, and print().

    def setupTags (self, **kwargs):
        """Sets up information for tags for output names"""
        necessaryKeys = set (['ifCond', 'tag'])
        allowedKeys   = set (['tagArg'])
        for key in kwargs.keys():
            if key in allowedKeys:
                continue
            if key in necessaryKeys:
                necessaryKeys.remove (key)
                continue
            # if we're here, then we have a key that's not understood
            print("Unknown option '%s'" % key)
            raise RuntimeError("Unknown option")
        if necessaryKeys:
            # if this is not empty, then we didn't have a key that was
            # necessary.
            print("Missing keys: %s" % necessaryKeys)
            raise runtimeError("Missing keys")
        tag = kwargs.get('tag')
        del kwargs['tag']
        self._tags[tag] = kwargs
        self._tagOrder.append (tag)

Member Data Documentation

_beenSet

VarParsing.VarParsing._beenSet

private

Definition at line 27 of file VarParsing.py.

Referenced by VarParsing.VarParsing.parseArguments(), and VarParsing.VarParsing.register().

_currentlyParsing

VarParsing.VarParsing._currentlyParsing

private

Definition at line 36 of file VarParsing.py.

Referenced by VarParsing.VarParsing.parseArguments(), and VarParsing.VarParsing.setDefault().

_info

VarParsing.VarParsing._info

private

Definition at line 28 of file VarParsing.py.

Referenced by VarParsing.VarParsing.__str__(), and VarParsing.VarParsing.register().

_lists

VarParsing.VarParsing._lists

private

Definition at line 25 of file VarParsing.py.

Referenced by VarParsing.VarParsing.__getattr__(), VarParsing.VarParsing.__str__(), VarParsing.VarParsing.clearList(), VarParsing.VarParsing.loadFromFile(), VarParsing.VarParsing.register(), and VarParsing.VarParsing.setDefault().

_maxLength

VarParsing.VarParsing._maxLength

private

Definition at line 30 of file VarParsing.py.

Referenced by VarParsing.VarParsing.__str__(), and VarParsing.VarParsing.register().

_noCommaSplit

VarParsing.VarParsing._noCommaSplit

private

Definition at line 33 of file VarParsing.py.

Referenced by VarParsing.VarParsing.register(), VarParsing.VarParsing.setDefault(), and VarParsing.VarParsing.setNoCommaSplit().

_noDefaultClear

VarParsing.VarParsing._noDefaultClear

private

Definition at line 34 of file VarParsing.py.

Referenced by VarParsing.VarParsing.register(), VarParsing.VarParsing.setDefault(), and VarParsing.VarParsing.setNoDefaultClear().

_register

VarParsing.VarParsing._register

private

Definition at line 26 of file VarParsing.py.

Referenced by VarParsing.VarParsing.__getattr__(), VarParsing.VarParsing._withTags(), VarParsing.VarParsing.clearList(), VarParsing.VarParsing.has_key(), VarParsing.VarParsing.loadFromFile(), VarParsing.VarParsing.parseArguments(), VarParsing.VarParsing.register(), VarParsing.VarParsing.setDefault(), VarParsing.VarParsing.setNoCommaSplit(), and VarParsing.VarParsing.setNoDefaultClear().

_setDuringParsing

VarParsing.VarParsing._setDuringParsing

private

Definition at line 35 of file VarParsing.py.

Referenced by VarParsing.VarParsing.setDefault().

_singletons

VarParsing.VarParsing._singletons

private

Definition at line 24 of file VarParsing.py.

Referenced by VarParsing.VarParsing.__getattr__(), VarParsing.VarParsing.__str__(), VarParsing.VarParsing._withTags(), VarParsing.VarParsing.register(), and VarParsing.VarParsing.setDefault().

_tagOrder

VarParsing.VarParsing._tagOrder

private

Definition at line 32 of file VarParsing.py.

Referenced by VarParsing.VarParsing._withTags(), and VarParsing.VarParsing.setupTags().

_tags

VarParsing.VarParsing._tags

private

Definition at line 31 of file VarParsing.py.

Referenced by VarParsing.VarParsing._withTags(), and VarParsing.VarParsing.setupTags().

_types

VarParsing.VarParsing._types

private

Definition at line 29 of file VarParsing.py.

Referenced by VarParsing.VarParsing.__getattr__(), VarParsing.VarParsing._convert(), VarParsing.VarParsing.register(), and VarParsing.VarParsing.setType().

commaRE

VarParsing.VarParsing.commaRE

static

Definition at line 16 of file VarParsing.py.

falseRE

VarParsing.VarParsing.falseRE

static

Definition at line 18 of file VarParsing.py.

inputFiles

VarParsing.VarParsing.inputFiles

Post-loading processing #.

sections

Definition at line 261 of file VarParsing.py.

Referenced by VarParsing.VarParsing.parseArguments().

multiplicity

VarParsing.VarParsing.multiplicity

static

Definition at line 14 of file VarParsing.py.

trueRE

VarParsing.VarParsing.trueRE

static

Definition at line 17 of file VarParsing.py.

varType

VarParsing.VarParsing.varType

static

Definition at line 15 of file VarParsing.py.

---

Generated for CMSSW Reference Manual by  1.8.14