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

Function Documentation

def EnablePSetHistory.auto_inspect

(

)

helpers for inspection ####

Definition at line 8 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 43 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 485 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 543 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 535 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 493 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 508 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 504 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 527 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 516 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 499 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 61 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 74 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 80 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 68 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 444 of file EnablePSetHistory.py.

References harvestTrackValidationPlots.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 471 of file EnablePSetHistory.py.

References harvestTrackValidationPlots.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 464 of file EnablePSetHistory.py.

References harvestTrackValidationPlots.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 460 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 126 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 153 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 136 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 140 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 108 of file EnablePSetHistory.py.

References join().

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 291 of file EnablePSetHistory.py.

References any(), ALCARECOTkAlBeamHalo_cff.filter, join(), list(), and 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 = filter(lambda x: not x['type'] == 'seq', modifications)
    checkpoint = self.__dict__['_Process__modifiedcheckpoint']
    if not checkpoint == None:
        modifications = filter(lambda x: any([x['name'].startswith(check) for check in checkpoint]), modifications)
    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 349 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 149 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 98 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 372 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 += self.paths.iteritems()
    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 265 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 53 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 364 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 403 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 396 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 428 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 410 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 419 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 437 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 202 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 184 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 102 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 281 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 57 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 478 of file EnablePSetHistory.py.

References harvestTrackValidationPlots.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 157 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 92 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 86 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 23 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 27 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 414 of file EnablePSetHistory.py.

EnablePSetHistory._modifications

private

Definition at line 399 of file EnablePSetHistory.py.