common Namespace Reference

Functions
def	analyzers_by_type (process, *types)
def	esproducers_by_type (process, *types)
def	filters_by_type (process, *types)
def	insert_modules_after (process, target, *modules)
def	insert_modules_before (process, target, *modules)
def	modules_by_type (process, *types)
def	producers_by_type (process, *types)
def	replace_with (fromObj, toObj)

Function Documentation

analyzers_by_type()

def common.analyzers_by_type	(		process,
		*	types
	)

Definition at line 14 of file common.py.

def analyzers_by_type(process, *types):
    "Find all EDAnalyzers in the Process that are instances of the given C++ type."
    return (analyzer for analyzer in process._Process__analyzers.values() if analyzer._TypedParameterizable__type in types)
 

esproducers_by_type()

def common.esproducers_by_type	(		process,
		*	types
	)

Definition at line 18 of file common.py.

def esproducers_by_type(process, *types):
    "Find all ESProducers in the Process that are instances of the given C++ type."
    return (module for module in process._Process__esproducers.values() if module._TypedParameterizable__type in types)
 

filters_by_type()

def common.filters_by_type	(		process,
		*	types
	)

Definition at line 10 of file common.py.

def filters_by_type(process, *types):
    "Find all EDFilters in the Process that are instances of the given C++ type."
    return (filter for filter in process._Process__filters.values() if filter._TypedParameterizable__type in types)
 

insert_modules_after()

def common.insert_modules_after	(		process,
			target,
		*	modules
	)

Definition at line 43 of file common.py.

def insert_modules_after(process, target, *modules):
    "Add the `modules` after the `target` in any Sequence, Paths or EndPath that contains the latter."
    for sequence in itertools.chain(
        six.itervalues(process._Process__sequences),
        six.itervalues(process._Process__paths),
        six.itervalues(process._Process__endpaths)
    ):
        try:
            position = sequence.index(target)
        except ValueError:
            continue
        else:
            for module in reversed(modules):
                sequence.insert(position+1, module)
 
 
# logic from Modifier.toModify from FWCore/ParameterSet/python/Config.py

insert_modules_before()

def common.insert_modules_before	(		process,
			target,
		*	modules
	)

Definition at line 27 of file common.py.

def insert_modules_before(process, target, *modules):
    "Add the `modules` before the `target` in any Sequence, Paths or EndPath that contains the latter."
    for sequence in itertools.chain(
        six.itervalues(process._Process__sequences),
        six.itervalues(process._Process__paths),
        six.itervalues(process._Process__endpaths)
    ):
        try:
            position = sequence.index(target)
        except ValueError:
            continue
        else:
            for module in reversed(modules):
                sequence.insert(position, module)
 
 

modules_by_type()

def common.modules_by_type	(		process,
		*	types
	)

Definition at line 22 of file common.py.

def modules_by_type(process, *types):
    "Find all modiles or other components in the Process that are instances of the given C++ type."
    return (module for module in process.__dict__.values() if hasattr(module, '_TypedParameterizable__type') and module._TypedParameterizable__type in types)
 
 

producers_by_type()

def common.producers_by_type	(		process,
		*	types
	)

Definition at line 6 of file common.py.

def producers_by_type(process, *types):
    "Find all EDProducers in the Process that are instances of the given C++ type."
    return (module for module in process._Process__producers.values() if module._TypedParameterizable__type in types)
 

Referenced by customizeHLTforCMSSW.synchronizeHCALHLTofflineRun2(), and customizeHLTforCMSSW.synchronizeHCALHLTofflineRun3on2018data().

replace_with()

def common.replace_with	(		fromObj,
			toObj
	)

Replace one object with a different one of the same type.

This function replaces the contents of `fromObj` object with those of `toObj`,
so all references ot it remain valid.

Definition at line 60 of file common.py.

def replace_with(fromObj, toObj):
    """Replace one object with a different one of the same type.
 
    This function replaces the contents of `fromObj` object with those of `toObj`,
    so all references ot it remain valid.
    """
 
    if not isinstance(toObj, type(fromObj)):
        raise TypeError('replaceWith requires both arguments to be the same type')
 
    if isinstance(toObj, cms._ModuleSequenceType):
        fromObj._seq = toObj._seq
 
    elif isinstance(toObj, cms._Parameterizable):
        # delete the old items, in case `toObj` is not a complete superset of `fromObj`
        for p in fromObj.parameterNames_():
            delattr(fromObj, p)
        for p in toObj.parameterNames_():
            setattr(fromObj, p, getattr(toObj, p))
        if isinstance(toObj, cms._TypedParameterizable):
            fromObj._TypedParameterizable__type = toObj._TypedParameterizable__type
 
    else:
        raise TypeError('replaceWith does not work with "%s" objects' % str(type(fromObj)))
 

References str.