EnablePSetHistory Namespace Reference

Classes
class	TestModificationTracking

Functions
def	auto_inspect ()
	helpers for inspection #### More...
def	new___init__ (self, l, k)
def	new__Module_name (self)
def	new__ModuleSequenceType__iadd__ (self, other)
def	new__ModuleSequenceType__imul__ (self, other)
def	new__ModuleSequenceType__init__ (self, arg, argv)
def	new__ModuleSequenceType_copy (self)
def	new__ModuleSequenceType_isModified (self)
def	new__ModuleSequenceType_remove (self, original)
def	new__ModuleSequenceType_replace (self, original, replacement)
def	new__ModuleSequenceType_resetModified (self)
def	new__place (self, name, mod, d)
def	new__placeLooper (self, name, mod)
def	new__placeService (self, typeName, mod)
def	new__placeSource (self, name, mod)
def	new__Sequenceable_name (self)
	sequence history #### More...
def	new__SequenceIgnore_name (self)
def	new__SequenceNegation_name (self)
def	new__SequencePlaceholder_name (self)
def	new_addAction (self, tool)
def	new_checkRecording (self)
def	new_deleteAction (self, i)
def	new_disableRecording (self)
def	new_dumpHistory (self, withImports=True)
def	new_dumpModifications (self, comments=True, process=True, module=False, sequence=True, value=True, sort=True, group=True)
def	new_dumpModificationsWithObjects (self, removeDuplicates=False)
def	new_enableRecording (self)
def	new_history (self, removeDuplicates=False)
def	new_items_ (self)
def	new_modificationCheckpoint (self)
def	new_modifiedObjects (self)
def	new_moduleItems_ (self)
def	new_Parameterizable_addParameter (self, name, value)
def	new_Parameterizable_init (self, a, k)
	parameterizable history #### More...
def	new_Parameterizable_resetModified (self)
def	new_Parameterizable_setattr (self, name, value)
def	new_Parameterizeable_delattr (self, name)
def	new_ParameterTypeBase_resetModified (self)
def	new_recurseDumpModifications_ (self, name, o)
def	new_recurseResetModified_ (self, o)
def	new_resetHistory (self)
def	new_resetModified (self)
def	new_resetModifiedObjects (self)
def	new_Sequence_name (self)
def	new_setattr (self, name, value)
def	new_setLooper_ (self, lpr)
def	new_setSchedule_ (self, sch)
def	new_SortedKeysDict__copy__ (self)
def	new_SortedKeysDict__deepcopy__ (self, memo=None)

Variables
	_isModified
	_modifications
	ACTIVATE_INSPECTION

Function Documentation

def EnablePSetHistory.auto_inspect

(

)

helpers for inspection ####

Definition at line 11 of file EnablePSetHistory.py.

Referenced by new__ModuleSequenceType__iadd__(), new__ModuleSequenceType__imul__(), new__ModuleSequenceType_remove(), new__ModuleSequenceType_replace(), new_Parameterizable_addParameter(), new_Parameterizable_setattr(), new_Parameterizeable_delattr(), and new_setattr().

def auto_inspect():
    if not ACTIVATE_INSPECTION:
        return [("unknown","unknown","unknown")]
    stack = inspect.stack()
    while len(stack)>=1 and len(stack[0])>=2 and ('FWCore/ParameterSet' in stack[0][1] or 'FWCore/GuiBrowsers' in stack[0][1]):
        stack = stack[1:]
    if len(stack)>=1 and len(stack[0])>=3:
        return stack
    else:
        return [("unknown","unknown","unknown")]

def EnablePSetHistory.new___init__	(		self,
			l,
			k
	)

Definition at line 46 of file EnablePSetHistory.py.

def new___init__(self,*l,**k):
    self.old___init__(*l,**k)
    self.__dict__['_Process__history'] = []
    self.__dict__['_Process__enableRecording'] = 0
    self.__dict__['_Process__modifiedobjects'] = []
    self.__dict__['_Process__modifiedcheckpoint'] = None
    self.__dict__['_Process__modifications'] = []
cms.Process.old___init__=cms.Process.__init__
cms.Process.__init__=new___init__

def EnablePSetHistory.new__Module_name

(

self

)

Definition at line 488 of file EnablePSetHistory.py.

def new__Module_name(self):
    if hasattr(self,'_Labelable__label'):
        return getattr(self,'_Labelable__label')
    elif hasattr(self,'_TypedParameterizable__type'):
        return 'unnamed(%s)'%getattr(self,'_TypedParameterizable__type')
    return type(self).__name__
cms._Module._name_ = new__Module_name

def EnablePSetHistory.new__ModuleSequenceType__iadd__	(		self,
			other
	)

Definition at line 546 of file EnablePSetHistory.py.

References auto_inspect().

def new__ModuleSequenceType__iadd__(self,other):
    stack = auto_inspect()
    self._isModified=True
    self._modifications.append({'file':stack[0][1],'line':stack[0][2],'action':'append','new':other._name_(),'old':None})
    return self.old__iadd__(other)
cms._ModuleSequenceType.old__iadd__ = cms._ModuleSequenceType.__iadd__
cms._ModuleSequenceType.__iadd__ = new__ModuleSequenceType__iadd__

def EnablePSetHistory.new__ModuleSequenceType__imul__	(		self,
			other
	)

Definition at line 538 of file EnablePSetHistory.py.

References auto_inspect().

def new__ModuleSequenceType__imul__(self,other):
    stack = auto_inspect()
    self._modifications.append({'file':stack[0][1],'line':stack[0][2],'action':'append','new':other._name_(),'old':None})
    self._isModified=True
    return self.old__iadd__(other)
cms._ModuleSequenceType.old__imul__ = cms._ModuleSequenceType.__imul__
cms._ModuleSequenceType.__imul__ = new__ModuleSequenceType__imul__

def EnablePSetHistory.new__ModuleSequenceType__init__	(		self,
			arg,
			argv
	)

Definition at line 496 of file EnablePSetHistory.py.

def new__ModuleSequenceType__init__(self,*arg,**argv):
    self._modifications = []
    self.old__init__(*arg,**argv)
cms._ModuleSequenceType.old__init__ = cms._ModuleSequenceType.__init__
cms._ModuleSequenceType.__init__ = new__ModuleSequenceType__init__

def EnablePSetHistory.new__ModuleSequenceType_copy

(

self

)

Definition at line 511 of file EnablePSetHistory.py.

def new__ModuleSequenceType_copy(self):
    returnValue = cms._ModuleSequenceType.__new__(type(self))
    returnValue.__init__(self._seq)
    returnValue._isModified = self._isModified
    returnValue._modifications = deepcopy(self._modifications)
    return returnValue
cms._ModuleSequenceType.copy = new__ModuleSequenceType_copy

def EnablePSetHistory.new__ModuleSequenceType_isModified

(

self

)

Definition at line 507 of file EnablePSetHistory.py.

def new__ModuleSequenceType_isModified(self):
    return self._isModified
cms._ModuleSequenceType.isModified = new__ModuleSequenceType_isModified

def EnablePSetHistory.new__ModuleSequenceType_remove	(		self,
			original
	)

Definition at line 530 of file EnablePSetHistory.py.

References auto_inspect().

def new__ModuleSequenceType_remove(self, original):
    stack = auto_inspect()
    self._isModified=True
    self._modifications.append({'file':stack[0][1],'line':stack[0][2],'action':'remove','old':original._name_(),'new':None})
    return self.old_remove(original)
cms._ModuleSequenceType.old_remove = cms._ModuleSequenceType.remove
cms._ModuleSequenceType.remove = new__ModuleSequenceType_remove

def EnablePSetHistory.new__ModuleSequenceType_replace	(		self,
			original,
			replacement
	)

Definition at line 519 of file EnablePSetHistory.py.

References auto_inspect().

def new__ModuleSequenceType_replace(self, original, replacement):
    stack = auto_inspect()
    self._isModified=True
    if replacement is None:
        self._modifications.append({'file':stack[0][1],'line':stack[0][2],'action':'replace','old':original._name_(),'new':None})
    else:
        self._modifications.append({'file':stack[0][1],'line':stack[0][2],'action':'replace','old':original._name_(),'new':replacement._name_()})
    return self.old_replace(original, replacement)
cms._ModuleSequenceType.old_replace = cms._ModuleSequenceType.replace
cms._ModuleSequenceType.replace = new__ModuleSequenceType_replace

def EnablePSetHistory.new__ModuleSequenceType_resetModified

(

self

)

Definition at line 502 of file EnablePSetHistory.py.

def new__ModuleSequenceType_resetModified(self):
    self._isModified=False
    self._modifications = []
cms._ModuleSequenceType.resetModified = new__ModuleSequenceType_resetModified

def EnablePSetHistory.new__place	(		self,
			name,
			mod,
			d
	)

Definition at line 64 of file EnablePSetHistory.py.

References mps_setup.append.

def new__place(self, name, mod, d):
    self.old__place(name, mod, d)
    if self._okToPlace(name, mod, d):
        self.__dict__['_Process__modifiedobjects'].append(mod)
cms.Process.old__place=cms.Process._place
cms.Process._place=new__place

def EnablePSetHistory.new__placeLooper	(		self,
			name,
			mod
	)

Definition at line 77 of file EnablePSetHistory.py.

References mps_setup.append.

def new__placeLooper(self, name, mod):
    self.old__placeLooper(name, mod)
    self.__dict__['_Process__modifiedobjects'].append(mod)
cms.Process.old__placeLooper=cms.Process._placeLooper
cms.Process._placeLooper=new__placeLooper

def EnablePSetHistory.new__placeService	(		self,
			typeName,
			mod
	)

Definition at line 83 of file EnablePSetHistory.py.

References mps_setup.append.

def new__placeService(self, typeName, mod):
    self.old__placeService(typeName, mod)
    self.__dict__['_Process__modifiedobjects'].append(mod)
cms.Process.old__placeService=cms.Process._placeService
cms.Process._placeService=new__placeService

def EnablePSetHistory.new__placeSource	(		self,
			name,
			mod
	)

Definition at line 71 of file EnablePSetHistory.py.

References mps_setup.append.

def new__placeSource(self, name, mod):
    self.old__placeSource(name, mod)
    self.__dict__['_Process__modifiedobjects'].append(mod)
cms.Process.old__placeSource=cms.Process._placeSource
cms.Process._placeSource=new__placeSource

def EnablePSetHistory.new__Sequenceable_name

(

self

)

sequence history ####

Definition at line 447 of file EnablePSetHistory.py.

References str.

def new__Sequenceable_name(self):
    return ''
cms._Sequenceable._name_ = new__Sequenceable_name

try:
    # for backwards-compatibility with CMSSW_3_10_X
    from FWCore.ParameterSet.SequenceTypes import _SequenceOperator

    def new__SequenceOperator_name(self):
        return str(self._left._name_())+str(self._pySymbol)+str(self._right._name_())
    _SequenceOperator._name_ = new__SequenceOperator_name    
except:
    pass

def EnablePSetHistory.new__SequenceIgnore_name

(

self

)

Definition at line 474 of file EnablePSetHistory.py.

References str.

def new__SequenceIgnore_name(self):
    if self._operand:
        return '-'+str(self._operand._name_())
    else:
        return '-()'
_SequenceIgnore._name_ = new__SequenceIgnore_name

def EnablePSetHistory.new__SequenceNegation_name

(

self

)

Definition at line 467 of file EnablePSetHistory.py.

References str.

def new__SequenceNegation_name(self):
    if self._operand:
        return '~'+str(self._operand._name_())
    else:
        return '~()'
_SequenceNegation._name_ = new__SequenceNegation_name    

def EnablePSetHistory.new__SequencePlaceholder_name

(

self

)

Definition at line 463 of file EnablePSetHistory.py.

def new__SequencePlaceholder_name(self):
    return self._name
SequencePlaceholder._name_ = new__SequencePlaceholder_name

def EnablePSetHistory.new_addAction	(		self,
			tool
	)

Definition at line 129 of file EnablePSetHistory.py.

References mps_setup.append.

def new_addAction(self,tool):
    if self.__dict__['_Process__enableRecording'] == 0:
        modifiedObjects=self.modifiedObjects()
        for m,o in self.dumpModificationsWithObjects():
            modifiedObjects+=o
        self.__dict__['_Process__history'].append((tool,modifiedObjects))
        self.resetModified()
        self.resetModifiedObjects()
cms.Process.addAction=new_addAction

def EnablePSetHistory.new_checkRecording

(

self

)

Definition at line 156 of file EnablePSetHistory.py.

def new_checkRecording(self):
    return self.__dict__['_Process__enableRecording']==0
cms.Process.checkRecording=new_checkRecording

def EnablePSetHistory.new_deleteAction	(		self,
			i
	)

Definition at line 139 of file EnablePSetHistory.py.

def new_deleteAction(self,i):
    del self.__dict__['_Process__history'][i]
cms.Process.deleteAction=new_deleteAction

def EnablePSetHistory.new_disableRecording

(

self

)

Definition at line 143 of file EnablePSetHistory.py.

def new_disableRecording(self):
    if self.__dict__['_Process__enableRecording'] == 0:
        # remember modifications in history
        self.__dict__['_Process__history']+=self.dumpModificationsWithObjects()
        self.resetModified()
        self.resetModifiedObjects()
    self.__dict__['_Process__enableRecording'] += 1
cms.Process.disableRecording=new_disableRecording

def EnablePSetHistory.new_dumpHistory	(		self,
			withImports = True
	)

Definition at line 111 of file EnablePSetHistory.py.

References join(), and edm.print().

def new_dumpHistory(self,withImports=True):
    dumpHistory=[]
    for item,objects in self.history():
        if isinstance(item,(str,unicode)):
            dumpHistory.append(item +"\n")
        else: # isTool
            print(item)
            dump=item.dumpPython()
            if isinstance(dump,tuple):
                if withImports and dump[0] not in dumpHistory:
                    dumpHistory.append(dump[0])
                dumpHistory.append(dump[1] +"\n")
            else:
                dumpHistory.append(dump +"\n")

    return ''.join(dumpHistory)
cms.Process.dumpHistory=new_dumpHistory

def EnablePSetHistory.new_dumpModifications	(		self,
			comments = True,
			process = True,
			module = False,
			sequence = True,
			value = True,
			sort = True,
			group = True
	)

Return some text describing all the modifications that have been made.

* comments: print out comments describing the file and line which triggered
            the modification, if determined.
* process: print "process." in front of every name
* module: only print out one entry per top-level module that has been
          changed, rather than the details
* sequence: include changes to sequences
* value: print out the latest value of each name
* sort: whether to sort all the names before printing (otherwise they're in
        more-or-less time order, within each category)

Definition at line 294 of file EnablePSetHistory.py.

References any(), join(), list(), and cms::dd.split().

def new_dumpModifications(self, comments=True, process=True, module=False, sequence=True, value=True, sort=True, group=True):
    """
    Return some text describing all the modifications that have been made.

    * comments: print out comments describing the file and line which triggered
                the modification, if determined.
    * process: print "process." in front of every name
    * module: only print out one entry per top-level module that has been
              changed, rather than the details
    * sequence: include changes to sequences
    * value: print out the latest value of each name
    * sort: whether to sort all the names before printing (otherwise they're in
            more-or-less time order, within each category)
    """
    modifications = self.recurseDumpModifications_('', self)
    text = []
    for name, o in self.items_():
        modifications += self.recurseDumpModifications_(name, o)
    if not sequence:
        modifications = [x for x in modifications if not x['type'] == 'seq']
    checkpoint = self.__dict__['_Process__modifiedcheckpoint']
    if not checkpoint == None:
        modifications = [x for x in modifications if any([x['name'].startswith(check) for check in checkpoint])]
    if module:
        value = False
        comments = False
        modules = list(set([m['name'].split('.')[0] for m in modifications]))
        if sort:
            modules = sorted(modules)
        if process:
            text = ['process.%s' % m for m in modules]
        else:
            text = modules
    else:
        if sort:
            modifications = sorted(modifications, key=lambda x: x['name'])
        for i, m in enumerate(modifications):
            t = ''
            if comments:
                if m['action'] == 'replace':
                    t += '# %(file)s:%(line)s replace %(old)s->%(new)s\n' % m
                elif m['action'] == 'remove':
                    t += '# %(file)s:%(line)s remove %(old)s\n' % m
                elif m['action'] == 'append':
                    t += '# %(file)s:%(line)s append %(new)s\n' % m
            if not group or i==len(modifications)-1 or not modifications[i+1]['name'] == m['name']:
                if process and value:
                    t += 'process.%s = %s' % (m['name'], m['dump'])
                elif value:
                    t += '%s = %s' % (m['name'], m['dump'])
                elif process:
                    t += 'process.%s' % (m['name'])
                else:
                    t += '%s' % (m['name'])
            text += [t]
    return '\n'.join(text)+'\n'
cms.Process.dumpModifications=new_dumpModifications

def EnablePSetHistory.new_dumpModificationsWithObjects	(		self,
			removeDuplicates = False
	)

Definition at line 352 of file EnablePSetHistory.py.

def new_dumpModificationsWithObjects(self, removeDuplicates=False):
    modifications = []
    last_modification=""
    for name, o in self.items_():
        for m in self.recurseDumpModifications_(name, o):
            # remove duplicate modifications
            if removeDuplicates and last_modification==m['name']:
                modifications.pop()
            last_modification=m['name']
            # add changes
            text = 'process.%s = %s' % (m['name'], m['dump'])
            modifications += [(text,[o])]
    return modifications
cms.Process.dumpModificationsWithObjects=new_dumpModificationsWithObjects

def EnablePSetHistory.new_enableRecording

(

self

)

Definition at line 152 of file EnablePSetHistory.py.

def new_enableRecording(self):
    self.__dict__['_Process__enableRecording'] -= 1
cms.Process.enableRecording=new_enableRecording

def EnablePSetHistory.new_history	(		self,
			removeDuplicates = False
	)

Definition at line 101 of file EnablePSetHistory.py.

def new_history(self, removeDuplicates=False):
    return self.__dict__['_Process__history']+self.dumpModificationsWithObjects(removeDuplicates)
cms.Process.history=new_history

def EnablePSetHistory.new_items_

(

self

)

Definition at line 375 of file EnablePSetHistory.py.

def new_items_(self):
    items = []
    if self.source:
        items += [("source", self.source)]
    if self.looper:
        items += [("looper", self.looper)]
    items += self.moduleItems_()
    items += self.outputModules.items()
    items += self.sequences.items()
    items += six.iteritems(self.paths)
    items += self.endpaths.items()
    items += self.services.items()
    items += self.es_producers.items()
    items += self.es_sources.items()
    items += self.es_prefers.items()
    items += self.psets.items()
    items += self.vpsets.items()
    if self.schedule:
        items += [("schedule", self.schedule)]
    return tuple(items)
cms.Process.items_=new_items_

def EnablePSetHistory.new_modificationCheckpoint

(

self

)

Set a checkpoint, ie get the current list of all known
top-level names and store them. Later, when we print out
modifications we ignore any modifications that do not affect
something in this list.

There is currently no way of clearing this, but I think this
is generally a use-once feature.

Definition at line 268 of file EnablePSetHistory.py.

References list().

def new_modificationCheckpoint(self):
    """
    Set a checkpoint, ie get the current list of all known
    top-level names and store them. Later, when we print out
    modifications we ignore any modifications that do not affect
    something in this list.

    There is currently no way of clearing this, but I think this
    is generally a use-once feature.
    """
    existing_names = set()
    for item in self.items_():
        existing_names.add(item[0])
    self.__dict__['_Process__modifiedcheckpoint'] = list(existing_names)
cms.Process.modificationCheckpoint=new_modificationCheckpoint

def EnablePSetHistory.new_modifiedObjects

(

self

)

Definition at line 56 of file EnablePSetHistory.py.

def new_modifiedObjects(self):
    return self.__dict__['_Process__modifiedobjects']
cms.Process.modifiedObjects=new_modifiedObjects

def EnablePSetHistory.new_moduleItems_

(

self

)

Definition at line 367 of file EnablePSetHistory.py.

def new_moduleItems_(self):
    items = []
    items += self.producers.items()
    items += self.filters.items()
    items += self.analyzers.items()
    return tuple(items)
cms.Process.moduleItems_=new_moduleItems_

def EnablePSetHistory.new_Parameterizable_addParameter	(		self,
			name,
			value
	)

Definition at line 406 of file EnablePSetHistory.py.

References auto_inspect().

def new_Parameterizable_addParameter(self, name, value):
    self.old__addParameter(name,value)
    stack = auto_inspect()
    self._modifications.append({'file':stack[0][1],'line':stack[0][2],'name':name,'old':None,'new':deepcopy(value),'action':'add'})
cms._Parameterizable.old__addParameter = cms._Parameterizable._Parameterizable__addParameter
cms._Parameterizable._Parameterizable__addParameter = new_Parameterizable_addParameter

def EnablePSetHistory.new_Parameterizable_init	(		self,
			a,
			k
	)

parameterizable history ####

Definition at line 399 of file EnablePSetHistory.py.

def new_Parameterizable_init(self,*a,**k):
    self.__dict__['_modifications'] = []
    self.old__init__(*a,**k)
    self._modifications = []
cms._Parameterizable.old__init__ = cms._Parameterizable.__init__
cms._Parameterizable.__init__ = new_Parameterizable_init

def EnablePSetHistory.new_Parameterizable_resetModified

(

self

)

Definition at line 431 of file EnablePSetHistory.py.

def new_Parameterizable_resetModified(self):
    self._isModified=False
    self._modifications = []
    for name in self.parameterNames_():
        param = self.__dict__[name]
        if isinstance(param, cms._Parameterizable):
            param.resetModified()
cms._Parameterizable.resetModified = new_Parameterizable_resetModified

def EnablePSetHistory.new_Parameterizable_setattr	(		self,
			name,
			value
	)

Definition at line 413 of file EnablePSetHistory.py.

References auto_inspect().

def new_Parameterizable_setattr(self, name, value):
    if (not self.isFrozen()) and (not name.startswith('_')) and (name in self.__dict__):
        stack = auto_inspect()
        self._modifications.append({'file':stack[0][1],'line':stack[0][2],'name':name,'old':deepcopy(self.__dict__[name]),'new':deepcopy(value),'action':'replace'})
        self._isModified = True
    self.old__setattr__(name,value)
cms._Parameterizable.old__setattr__ = cms._Parameterizable.__setattr__
cms._Parameterizable.__setattr__ = new_Parameterizable_setattr

def EnablePSetHistory.new_Parameterizeable_delattr	(		self,
			name
	)

Definition at line 422 of file EnablePSetHistory.py.

References auto_inspect().

def new_Parameterizeable_delattr(self, name):
    if not self.isFrozen():
        stack = auto_inspect()
        self._modifications.append({'file':stack[0][1],'line':stack[0][2],'name':name,'old':deepcopy(self.__dict__[name]), 'new':None,'action':'delete'})
    self.old__delattr__(name)
cms._Parameterizable.old__delattr__ = cms._Parameterizable.__delattr__
cms._Parameterizable.__delattr__ = new_Parameterizeable_delattr

def EnablePSetHistory.new_ParameterTypeBase_resetModified

(

self

)

Definition at line 440 of file EnablePSetHistory.py.

def new_ParameterTypeBase_resetModified(self):
    self._isModified=False
    self._modifications = []
cms._ParameterTypeBase.resetModified = new_ParameterTypeBase_resetModified

def EnablePSetHistory.new_recurseDumpModifications_	(		self,
			name,
			o
	)

Recursively return a standardised list of modifications
from the object hierarchy.

Definition at line 205 of file EnablePSetHistory.py.

References ConfigBuilder.dumpPython().

def new_recurseDumpModifications_(self, name, o):
    """
    Recursively return a standardised list of modifications
    from the object hierarchy.
    """
    modifications = []
    if isinstance(o, cms._ModuleSequenceType):
        if o._isModified:
            for mod in o._modifications:
                modifications.append({'name':name,
                                      'action':mod['action'],
                                      'old': mod['old'],
                                      'new': mod['new'],
                                      'file': mod['file'],
                                      'line': mod['line'],
                                      'dump': o.dumpPython({}),
                                      'type': 'seq'})

    if isinstance(o, cms._Parameterizable):
        for mod in o._modifications:
            paramname = mod['name']
            if hasattr(o, paramname):
                paramvalue = getattr(o, paramname)
            else:
                paramvalue = None
            if isinstance(paramvalue,cms._ParameterTypeBase):
                dump = paramvalue.dumpPython()
            else:
                dump = paramvalue
            modifications.append({'name': '%s.%s' %(name, paramname),
                                  'old': mod['old'],
                                  'new': mod['new'],
                                  'file': mod['file'],
                                  'line': mod['line'],
                                  'action': mod['action'],
                                  'dump': dump,
                                  'type': 'param'})

        # Loop over any child elements
        for key in o.parameterNames_():
            value = getattr(o,key)
            modifications += self.recurseDumpModifications_("%s.%s" % (name, key), value)

    if isinstance(o, cms._ValidatingListBase):
        for index, item in enumerate(o):
            modifications += self.recurseDumpModifications_("%s[%s]" % (name, index), item)
    if isinstance(o, cms.Process):
        for mod in o.__dict__['_Process__modifications']:
            if hasattr(o, mod['name']) and hasattr(getattr(o, mod['name']), 'dumpPython'):
                dump = getattr(o, mod['name']).dumpPython()
            else:
                dump = None
            modifications.append({'name': mod['name'],
                                  'action': mod['action'],
                                  'old': mod['old'],
                                  'new': mod['new'],
                                  'dump': dump,
                                  'file': mod['file'],
                                  'line': mod['line'],
                                  'type': 'process'})
    return modifications
cms.Process.recurseDumpModifications_=new_recurseDumpModifications_

def EnablePSetHistory.new_recurseResetModified_	(		self,
			o
	)

Empty all the _modifications lists for
all objects beneath this one.

Definition at line 187 of file EnablePSetHistory.py.

def new_recurseResetModified_(self, o):
    """
    Empty all the _modifications lists for
    all objects beneath this one.
    """
    properties = []
    if isinstance(o, cms._ModuleSequenceType):
        o.resetModified()
    if isinstance(o, cms._Parameterizable):
        o.resetModified()
        for key in o.parameterNames_():
            value = getattr(o,key)
            self.recurseResetModified_(value)
    if isinstance(o, cms._ValidatingListBase):
        for index,item in enumerate(o):
            self.recurseResetModified_(item)
cms.Process.recurseResetModified_=new_recurseResetModified_

def EnablePSetHistory.new_resetHistory

(

self

)

Definition at line 105 of file EnablePSetHistory.py.

def new_resetHistory(self):
    self.__dict__['_Process__history'] = []
    self.resetModified()
    self.resetModifiedObjects()
cms.Process.resetHistory=new_resetHistory

def EnablePSetHistory.new_resetModified

(

self

)

Empty out all the modification lists, so we only see changes that
happen from now onwards.

Definition at line 284 of file EnablePSetHistory.py.

def new_resetModified(self):
    """
    Empty out all the modification lists, so we only see changes that
    happen from now onwards.
    """
    self.__dict__['_Process__modified'] = []
    for name, o in self.items_():
        self.recurseResetModified_(o)
cms.Process.resetModified=new_resetModified

def EnablePSetHistory.new_resetModifiedObjects

(

self

)

Definition at line 60 of file EnablePSetHistory.py.

def new_resetModifiedObjects(self):
    self.__dict__['_Process__modifiedobjects'] = []
cms.Process.resetModifiedObjects=new_resetModifiedObjects

def EnablePSetHistory.new_Sequence_name

(

self

)

Definition at line 481 of file EnablePSetHistory.py.

References str.

def new_Sequence_name(self):
    if self._seq:
        return '('+str(self._seq._name_())+')'
    else:
        return '()'
cms.Sequence._name_ = new_Sequence_name

def EnablePSetHistory.new_setattr	(		self,
			name,
			value
	)

This catches modifications that occur during process.load,
and only records a modification if there was an existing object
and the version after __setattr__ has a different id().
This does not mean that the object is different, only redefined.
We still really need a recursive-comparison function for parameterizeable
objects to determine if a real change has been made.

Definition at line 160 of file EnablePSetHistory.py.

References auto_inspect(), and triggerObjects_cff.id.

def new_setattr(self, name, value):
    """
    This catches modifications that occur during process.load,
    and only records a modification if there was an existing object
    and the version after __setattr__ has a different id().
    This does not mean that the object is different, only redefined.
    We still really need a recursive-comparison function for parameterizeable
    objects to determine if a real change has been made.
    """
    old = None
    existing = False
    if not name.startswith('_Process__'):
        existing = hasattr(self, name)
        if existing:
            old = getattr(self, name)
    self.old__setattr__(name, value)
    if existing:
        if id(getattr(self, name)) != id(old):
            stack = auto_inspect()
            self.__dict__['_Process__modifications'] += [{'name': name,
                                                          'old': deepcopy(old), 
                                                          'new': deepcopy(getattr(self, name)),
                                                          'file':stack[0][1],'line':stack[0][2],
                                                          'action': 'replace'}]
cms.Process.old__setattr__ = cms.Process.__setattr__
cms.Process.__setattr__ = new_setattr

def EnablePSetHistory.new_setLooper_	(		self,
			lpr
	)

Definition at line 95 of file EnablePSetHistory.py.

References mps_setup.append.

def new_setLooper_(self, lpr):
    self.old_setLooper_(lpr)
    self.__dict__['_Process__modifiedobjects'].append(lpr)
cms.Process.old_setLooper_=cms.Process.setLooper_
cms.Process.setLooper_=new_setLooper_

def EnablePSetHistory.new_setSchedule_	(		self,
			sch
	)

Definition at line 89 of file EnablePSetHistory.py.

References mps_setup.append.

def new_setSchedule_(self, sch):
    self.old_setSchedule_(sch)
    self.__dict__['_Process__modifiedobjects'].append(sch)
cms.Process.old_setSchedule_=cms.Process.setSchedule_
cms.Process.setSchedule_=new_setSchedule_

def EnablePSetHistory.new_SortedKeysDict__copy__

(

self

)

Definition at line 26 of file EnablePSetHistory.py.

def new_SortedKeysDict__copy__(self):
    return self.__class__(self)
typ.SortedKeysDict.__copy__ = new_SortedKeysDict__copy__

def EnablePSetHistory.new_SortedKeysDict__deepcopy__	(		self,
			memo = None
	)

Definition at line 30 of file EnablePSetHistory.py.

References triggerObjects_cff.id.

def new_SortedKeysDict__deepcopy__(self, memo=None):
    from copy import deepcopy
    if memo is None:
        memo = {}
    d = memo.get(id(self), None)
    if d is not None:
        return d
    memo[id(self)] = d = self.__class__()
    d.__init__(deepcopy(self.items(), memo))
    return d
typ.SortedKeysDict.__deepcopy__ = new_SortedKeysDict__deepcopy__

Variable Documentation

EnablePSetHistory._isModified

private

Definition at line 417 of file EnablePSetHistory.py.

EnablePSetHistory._modifications

private

Definition at line 402 of file EnablePSetHistory.py.

EnablePSetHistory.ACTIVATE_INSPECTION

Definition at line 7 of file EnablePSetHistory.py.