Mixins._Parameterizable Class Reference

Inheritance diagram for Mixins._Parameterizable:

Public Member Functions
def	__delattr__
def	__init__ (self, arg, kargs)
def	__repr__ (self)
def	__setattr__
def	dumpPython
def	getParameter (self, params)
def	hasParameter (self, params)
def	insertContentsInto (self, parameterSet)
def	isFrozen (self)
def	isModified (self)
def	parameterNames_ (self)
def	parameters_ (self)
def	setIsFrozen (self)
def	update_ (self, d)

Private Member Functions
def	__addParameter
def	__setParameters (self, parameters)
def	__setParametersFromArg (self, arg)

Static Private Member Functions
def	__raiseBadSetAttr

Private Attributes
	__validator
	_isFrozen
	_isModified

Detailed Description

Base class for classes which allow addition of _ParameterTypeBase data

Definition at line 169 of file Mixins.py.

Constructor & Destructor Documentation

__init__()

def Mixins._Parameterizable.__init__	(		self,
			arg,
			kargs
	)

Definition at line 171 of file Mixins.py.

References Mixins._Parameterizable.__setParameters(), and Mixins._Parameterizable.__setParametersFromArg().

    def __init__(self,*arg,**kargs):
        self.__dict__['_Parameterizable__parameterNames'] = []
        self.__dict__["_isFrozen"] = False
        self.__dict__['_Parameterizable__validator'] = None
        """The named arguments are the 'parameters' which are added as 'python attributes' to the object"""
        if len(arg) != 0:
            self.__setParametersFromArg(*arg)
        self.__setParameters(kargs)
        self._isModified = False
        

Member Function Documentation

__addParameter()

def Mixins._Parameterizable.__addParameter (   self,   name  )

private

Definition at line 235 of file Mixins.py.

Referenced by Mixins._Parameterizable.__setattr__(), Modules.SwitchProducer.__setattr__(), Mixins._Parameterizable.__setParameters(), and Modules.SwitchProducer.__setParameters().

    def __addParameter(self, name:str, value):
        if name == 'allowAnyLabel_':
            self.__validator = value
            self._isModified = True
            return
        if not isinstance(value,_ParameterTypeBase):
            if self.__validator is not None:
                value = self.__validator.convert_(value)
            else:
                self.__raiseBadSetAttr(name)
        if name in self.__dict__:
            message = "Duplicate insert of member " + name
            message += "\nThe original parameters are:\n"
            message += self.dumpPython() + '\n'
            raise ValueError(message)
        self.__dict__[name]=value
        self.__parameterNames.append(name)
        self._isModified = True

__delattr__()

def Mixins._Parameterizable.__delattr__	(		self,
			name
	)

Definition at line 312 of file Mixins.py.

References Mixins._ParameterTypeBase.isFrozen(), Mixins._Parameterizable.isFrozen(), and MatrixUtil.remove().

    def __delattr__(self,name:str):
        if self.isFrozen():
            raise ValueError("Object already added to a process. It is read only now")
        super(_Parameterizable,self).__delattr__(name)
        self.__parameterNames.remove(name)

__raiseBadSetAttr()

def Mixins._Parameterizable.__raiseBadSetAttr (   name )

staticprivate

Definition at line 318 of file Mixins.py.

    def __raiseBadSetAttr(name:str):
        raise TypeError(name+" does not already exist, so it can only be set to a CMS python configuration type")

__repr__()

def Mixins._Parameterizable.__repr__	(		self,
			str
	)

Definition at line 392 of file Mixins.py.

References Mixins._ParameterTypeBase.dumpPython(), Mixins.UsingBlock.dumpPython(), Mixins._Parameterizable.dumpPython(), Config.Process.dumpPython(), Config.SubProcess.dumpPython(), and Config.ProcessAccelerator.dumpPython().

Referenced by datamodel.Object.__str__().

    def __repr__(self) -> str:
        return self.dumpPython()

__setattr__()

def Mixins._Parameterizable.__setattr__	(		self,
			name
	)

Definition at line 272 of file Mixins.py.

References Mixins._Parameterizable.__addParameter(), Mixins._ParameterTypeBase._isModified, Mixins._SimpleParameterTypeBase._isModified, Mixins._Parameterizable._isModified, Mixins._ParameterTypeBase.dumpPython(), Mixins.UsingBlock.dumpPython(), Mixins._Parameterizable.dumpPython(), Config.Process.dumpPython(), Config.SubProcess.dumpPython(), Config.ProcessAccelerator.dumpPython(), Mixins._ParameterTypeBase.isFrozen(), Mixins._Parameterizable.isFrozen(), and reco::JetExtendedAssociation.setValue().

Referenced by GenObject.GenObject.setValue().

    def __setattr__(self,name:str,value):
        #since labels are not supposed to have underscores at the beginning
        # I will assume that if we have such then we are setting an internal variable
        if self.isFrozen() and not (name in ["_Labelable__label","_isFrozen"] or name.startswith('_')): 
            message = "Object already added to a process. It is read only now\n"
            message +=  "    %s = %s" %(name, value)
            message += "\nThe original parameters are:\n"
            message += self.dumpPython() + '\n'           
            raise ValueError(message)
        # underscored names bypass checking for _ParameterTypeBase
        if name[0]=='_':
            super(_Parameterizable,self).__setattr__(name,value)
        elif not name in self.__dict__:
            self.__addParameter(name, value)
            self._isModified = True
        else:
            # handle the case where users just replace with a value, a = 12, rather than a = cms.int32(12)
            if isinstance(value,_ParameterTypeBase):
                self.__dict__[name] = self.__dict__[name]._checkAndReturnValueWithType(value)
            else:
                self.__dict__[name].setValue(value)
            self._isModified = True

__setParameters()

def Mixins._Parameterizable.__setParameters (   self,   parameters  )

private

Definition at line 263 of file Mixins.py.

References Mixins._Parameterizable.__addParameter(), and Mixins._Parameterizable.__validator.

Referenced by Mixins._Parameterizable.__init__(), and Mixins._Parameterizable.__setParametersFromArg().

    def __setParameters(self,parameters):
        v = None
        for name,value in parameters.items():
            if name == 'allowAnyLabel_':
                v = value
                continue
            self.__addParameter(name, value)
        if v is not None:
            self.__validator=v

__setParametersFromArg()

def Mixins._Parameterizable.__setParametersFromArg (   self,   arg  )

private

Definition at line 253 of file Mixins.py.

References Mixins._Parameterizable.__setParameters().

Referenced by Mixins._Parameterizable.__init__().

    def __setParametersFromArg(self, *arg):
        for block in arg:
            # Allow __PSet for testing
            if type(block).__name__ not in ["PSet", "__PSet", "dict"]:
                raise ValueError("Only PSets can be passed as unnamed argument blocks.  This is a "+type(block).__name__)
            if isinstance(block,dict):
                self.__setParameters(block)
            else:
                self.__setParameters(block.parameters_())

dumpPython()

def Mixins._Parameterizable.dumpPython	(		self,
			options
	)

Definition at line 320 of file Mixins.py.

References Mixins._Parameterizable.__validator, join(), and Mixins._Parameterizable.parameterNames_().

Referenced by Modules.SwitchProducer.__addParameter(), Types._AllowedParameterTypes.__init__(), Mixins._Parameterizable.__repr__(), Mixins._Parameterizable.__setattr__(), and Modules.SwitchProducer.__setattr__().

    def dumpPython(self, options:PrintOptions=PrintOptions()) -> str:
        specialImportRegistry.registerUse(self)
        sortedNames = sorted(self.parameterNames_())
        if len(sortedNames) > 200:
        #Too many parameters for a python function call
        # The solution is to create a temporary dictionary which
        # is constructed by concatenating long lists (with maximum
        # 200 entries each) together.
        # This looks like
        #  **dict( [(...,...), ...] + [...] + ... )
            others = []
            usings = []
            for name in sortedNames:
                param = self.__dict__[name]
                # we don't want minuses in names
                name2 = name.replace('-','_')
                options.indent()
                #_UsingNodes don't get assigned variables
                if name.startswith("using_"):
                    usings.append(options.indentation()+param.dumpPython(options))
                else:
                    others.append((name2, param.dumpPython(options)))
                options.unindent()

            resultList = ',\n'.join(usings)
            longOthers = options.indentation()+"**dict(\n"
            options.indent()
            longOthers += options.indentation()+"[\n"
            entriesInList = 0
            options.indent()
            for n,v in others:
                entriesInList +=1
                if entriesInList > 200:
                    #need to start a new list
                    options.unindent()
                    longOthers += options.indentation()+"] +\n"+options.indentation()+"[\n"
                    entriesInList = 0
                    options.indent()
                longOthers += options.indentation()+'("'+n+'" , '+v+' ),\n'
            
            longOthers += options.indentation()+"]\n"
            options.unindent()
            longOthers +=options.indentation()+")\n"
            options.unindent()
            ret = []
            if resultList:
                ret.append(resultList)
            if longOthers:
                ret.append(longOthers)
            return ",\n".join(ret)
        #Standard case, small number of parameters
        others = []
        usings = []
        for name in sortedNames:
            param = self.__dict__[name]
            # we don't want minuses in names
            name2 = name.replace('-','_')
            options.indent()
            #_UsingNodes don't get assigned variables
            if name.startswith("using_"):
                usings.append(options.indentation()+param.dumpPython(options))
            else:
                others.append(options.indentation()+name2+' = '+param.dumpPython(options))
            options.unindent()
        # usings need to go first
        resultList = usings
        resultList.extend(others)
        if self.__validator is not None:
            options.indent()
            resultList.append(options.indentation()+"allowAnyLabel_="+self.__validator.dumpPython(options))
            options.unindent()
        return ',\n'.join(resultList)+'\n'

getParameter()

def Mixins._Parameterizable.getParameter	(		self,
			params
	)

_getParameter_

Retrieve the specified parameter from the PSet Provided
given the attribute chain

returns None if not found

Definition at line 208 of file Mixins.py.

Referenced by Mixins._Parameterizable.hasParameter().

    def getParameter(self, params):
        """
        _getParameter_

        Retrieve the specified parameter from the PSet Provided
        given the attribute chain

        returns None if not found
        """
        lastParam = self
        # Don't accidentally iterate over letters in a string
        if type(params).__name__ == 'str':
            return getattr(self, params, None)
        for param in params:
            lastParam = getattr(lastParam, param, None)
            if lastParam == None:
                return None
        return lastParam

hasParameter()

def Mixins._Parameterizable.hasParameter	(		self,
			params,
			bool
	)

_hasParameter_

check that pset provided has the attribute chain
specified.

Eg, if params is [ 'attr1', 'attr2', 'attr3' ]
check for pset.attr1.attr2.attr3

returns True if parameter exists, False if not

Definition at line 194 of file Mixins.py.

References DropBoxMetadata::Parameters.getParameter(), Args.getParameter(), QIE8Simulator.getParameter(), AbsElectronicODERHS.getParameter(), SiStripLorentzAngleCalibration.getParameter(), SiPixelLorentzAngleCalibration.getParameter(), IntegratedCalibrationBase.getParameter(), SiStripBackplaneCalibration.getParameter(), edm::ParameterSet.getParameter(), and Mixins._Parameterizable.getParameter().

    def hasParameter(self, params) -> bool:
        """
        _hasParameter_

        check that pset provided has the attribute chain
        specified.

        Eg, if params is [ 'attr1', 'attr2', 'attr3' ]
        check for pset.attr1.attr2.attr3

        returns True if parameter exists, False if not
        """
        return (self.getParameter(params) != None)

insertContentsInto()

def Mixins._Parameterizable.insertContentsInto	(		self,
			parameterSet
	)

Definition at line 394 of file Mixins.py.

References Mixins._Parameterizable.parameterNames_().

Referenced by Modules.Service.insertInto(), Mixins._TypedParameterizable.insertInto(), and Types.PSet.insertInto().

    def insertContentsInto(self, parameterSet):
        for name in self.parameterNames_():
            param = getattr(self,name)
            param.insertInto(parameterSet, name)

isFrozen()

def Mixins._Parameterizable.isFrozen	(		self,
			bool
	)

Definition at line 306 of file Mixins.py.

References Mixins._ParameterTypeBase._isFrozen, and Mixins._Parameterizable._isFrozen.

Referenced by Mixins._Parameterizable.__delattr__(), Mixins._Parameterizable.__setattr__(), and Modules.SwitchProducer.__setattr__().

    def isFrozen(self) -> bool:
        return self._isFrozen

isModified()

def Mixins._Parameterizable.isModified	(		self,
			bool
	)

Definition at line 184 of file Mixins.py.

References Mixins._ParameterTypeBase._isModified, Mixins._SimpleParameterTypeBase._isModified, Mixins._Parameterizable._isModified, and Mixins._Parameterizable.parameterNames_().

    def isModified(self) -> bool:
        if self._isModified:
            return True
        for name in self.parameterNames_():
            param = self.__dict__[name]
            if isinstance(param, _Parameterizable) and param.isModified():
                self._isModified = True
                return True
        return False

parameterNames_()

def Mixins._Parameterizable.parameterNames_

(

self

)

Returns the name of the parameters

Definition at line 181 of file Mixins.py.

Referenced by Modules.SwitchProducer._chooseCase(), Modules.SwitchProducer.appendToProcessDescLists_(), Modules.SwitchProducer.clone(), Types.PSet.configValue(), Mixins._TypedParameterizable.dumpConfig(), Mixins._Parameterizable.dumpPython(), Modules.SwitchProducer.dumpPython(), Mixins._TypedParameterizable.dumpPython(), Types.EDAlias.dumpPython(), Modules.ESPrefer.dumpPythonAs(), Mixins._TypedParameterizable.dumpPythonAttributes(), Mixins._Parameterizable.insertContentsInto(), Modules.SwitchProducer.insertInto(), Types.EDAlias.insertInto(), Mixins._Parameterizable.isModified(), Modules.SwitchProducer.modulesForConditionalTask_(), Mixins._Parameterizable.parameters_(), and Modules.SwitchProducer.setLabel().

    def parameterNames_(self):
        """Returns the name of the parameters"""
        return self.__parameterNames[:]

parameters_()

def Mixins._Parameterizable.parameters_

(

self

)

Returns a dictionary of copies of the user-set parameters

Definition at line 227 of file Mixins.py.

References Mixins._Parameterizable.parameterNames_().

Referenced by Mixins._TypedParameterizable.clone(), Types.PSet.clone(), Types.EDAlias.clone(), and Mixins._TypedParameterizable.copy().

    def parameters_(self):
        """Returns a dictionary of copies of the user-set parameters"""
        import copy
        result = dict()
        for name in self.parameterNames_():
               result[name]=copy.deepcopy(self.__dict__[name])
        return result

setIsFrozen()

def Mixins._Parameterizable.setIsFrozen

(

self

)

Definition at line 308 of file Mixins.py.

Referenced by Modules._Module.__init__().

    def setIsFrozen(self):
        self._isFrozen = True
        for name in self.parameterNames_():
            self.__dict__[name].setIsFrozen() 

update_()

def Mixins._Parameterizable.update_	(		self,
			d
	)

"Takes a PSet or dict and adds the entries as parameters. Already existing parameters will be overwritten.

Definition at line 294 of file Mixins.py.

References mps_monitormerge.items.

    def update_(self, d):
        """"Takes a PSet or dict and adds the entries as parameters. Already existing parameters will be overwritten.
        """
        if type(d).__name__ not in ["PSet", "__PSet", "dict"]:
            raise ValueError("Only PSets or dicts can be passed to update_.  This is a "+type(d).__name__)

        items = d.items() if isinstance(d, dict) else d.parameters_().items()
        for k,v in items:
                setattr(self, k, v)

Member Data Documentation

__validator

Mixins._Parameterizable.__validator

private

Definition at line 237 of file Mixins.py.

Referenced by Mixins._Parameterizable.__setParameters(), and Mixins._Parameterizable.dumpPython().

_isFrozen

Mixins._Parameterizable._isFrozen

private

Definition at line 309 of file Mixins.py.

Referenced by SequenceTypes._ModuleSequenceType.isFrozen(), and Mixins._Parameterizable.isFrozen().

_isModified

Mixins._Parameterizable._isModified

private

Definition at line 179 of file Mixins.py.

Referenced by Modules.SwitchProducer.__addParameter(), Mixins._Parameterizable.__setattr__(), Modules.SwitchProducer.__setattr__(), Mixins._TypedParameterizable.copy(), and Mixins._Parameterizable.isModified().