4 from Options
import Options
10 from Mixins
import PrintOptions,_ParameterTypeBase,_SimpleParameterTypeBase, _Parameterizable, _ConfigureComponent, _TypedParameterizable, _Labelable, _Unlabelable, _ValidatingListBase
14 from Modules
import _Module
15 from SequenceTypes
import *
16 from SequenceTypes
import _ModuleSequenceType, _Sequenceable
17 from SequenceVisitors
import PathValidator, EndPathValidator
18 from Utilities
import *
21 from ExceptionHandling
import *
24 if sys.getrecursionlimit()<5000:
25 sys.setrecursionlimit(5000)
29 Raise an exception if called by special config files. This checks
30 the call or import stack for the importing file. An exception is raised if
31 the importing module is not in allowedPatterns and if it is called too deeply:
32 minLevel = 2: inclusion by top lvel cfg only
33 minLevel = 1: No inclusion allowed
34 allowedPatterns = ['Module1','Module2/SubModule1'] allows import
35 by any module in Module1 or Submodule1
41 ignorePatterns = [
'FWCore/ParameterSet/Config.py',
'<string>']
42 CMSSWPath = [os.environ[
'CMSSW_BASE'],os.environ[
'CMSSW_RELEASE_BASE']]
46 for item
in inspect.stack():
50 for pattern
in CMSSWPath:
51 if item[1].
find(pattern) != -1:
54 if item[1].
find(
'/') == -1:
57 for pattern
in ignorePatterns:
58 if item[1].
find(pattern) != -1:
62 if inPath
and not ignore:
63 trueStack.append(item[1])
65 importedFile = trueStack[0]
67 if len(trueStack) > 1:
68 importedBy = trueStack[1]
70 for pattern
in allowedPatterns:
71 if importedBy.find(pattern) > -1:
74 if len(trueStack) <= minLevel:
77 raise ImportError(
"Inclusion of %s is allowed only by cfg or specified cfi files."
81 """Look inside the module and find the Processes it contains"""
85 if isinstance(module,dict):
86 if 'process' in module:
90 if hasattr(module,
'process'):
91 if isinstance(module.process,Process):
92 process = module.process
94 raise RuntimeError(
"The attribute named 'process' does not inherit from the Process class")
96 raise RuntimeError(
"no 'process' attribute found in the module, please add one")
101 """Root class for a CMS configuration process"""
103 """The argument 'name' will be the name applied to this Process
104 Can optionally pass as additional arguments cms.Modifier instances
105 which will be used ot modify the Process as it is built
107 self.__dict__[
'_Process__name'] = name
108 if not name.isalnum():
109 raise RuntimeError(
"Error: The process name is an empty string or contains non-alphanumeric characters")
110 self.__dict__[
'_Process__filters'] = {}
111 self.__dict__[
'_Process__producers'] = {}
112 self.__dict__[
'_Process__source'] =
None
113 self.__dict__[
'_Process__looper'] =
None
114 self.__dict__[
'_Process__subProcess'] =
None
115 self.__dict__[
'_Process__schedule'] =
None
116 self.__dict__[
'_Process__analyzers'] = {}
117 self.__dict__[
'_Process__outputmodules'] = {}
120 self.__dict__[
'_Process__sequences'] = {}
121 self.__dict__[
'_Process__services'] = {}
122 self.__dict__[
'_Process__essources'] = {}
123 self.__dict__[
'_Process__esproducers'] = {}
124 self.__dict__[
'_Process__esprefers'] = {}
125 self.__dict__[
'_Process__aliases'] = {}
126 self.__dict__[
'_Process__psets']={}
127 self.__dict__[
'_Process__vpsets']={}
128 self.__dict__[
'_cloneToObjectDict'] = {}
130 self.__dict__[
'_Process__InExtendCall'] =
False
131 self.__dict__[
'_Process__partialschedules'] = {}
133 self.__dict__[
'_Process__modifiers'] = Mods
134 for m
in self.__modifiers:
139 _Module.__isStrict__ =
True
143 """Returns a string containing all the EDProducer labels separated by a blank"""
146 """Returns a string containing all the EDAnalyzer labels separated by a blank"""
149 """Returns a string containing all the EDFilter labels separated by a blank"""
152 """Returns a string containing all the Path names separated by a blank"""
159 Since cloneToObjectDict stores a hash of objects by their
160 id() it needs to be updated when unpickling to use the
161 new object id values instantiated during the unpickle.
164 self.__dict__.update(pkldict)
166 for value
in self._cloneToObjectDict.values():
167 tmpDict[id(value)] = value
168 self.__dict__[
'_cloneToObjectDict'] = tmpDict
173 """returns a dict of the filters which have been added to the Process"""
175 filters = property(filters_, doc=
"dictionary containing the filters for the process")
179 if not name.isalnum():
180 raise RuntimeError(
"Error: The process name is an empty string or contains non-alphanumeric characters")
181 self.__dict__[
'_Process__name'] = name
182 process = property(name_,setName_, doc=
"name of the process")
184 """returns a dict of the producers which have been added to the Process"""
186 producers = property(producers_,doc=
"dictionary containing the producers for the process")
188 """returns the source which has been added to the Process or None if none have been added"""
192 source = property(source_,setSource_,doc=
'the main source or None if not set')
194 """returns the looper which has been added to the Process or None if none have been added"""
198 looper = property(looper_,setLooper_,doc=
'the main looper or None if not set')
200 """returns the sub-process which has been added to the Process or None if none have been added"""
201 return self.__subProcess
204 subProcess = property(subProcess_,setSubProcess_,doc=
'the SubProcess or None if not set')
206 """returns a dict of the analyzers which have been added to the Process"""
208 analyzers = property(analyzers_,doc=
"dictionary containing the analyzers for the process")
210 """returns a dict of the output modules which have been added to the Process"""
212 outputModules = property(outputModules_,doc=
"dictionary containing the output_modules for the process")
214 """returns a dict of the paths which have been added to the Process"""
216 paths = property(paths_,doc=
"dictionary containing the paths for the process")
218 """returns a dict of the endpaths which have been added to the Process"""
220 endpaths = property(endpaths_,doc=
"dictionary containing the endpaths for the process")
222 """returns a dict of the sequences which have been added to the Process"""
224 sequences = property(sequences_,doc=
"dictionary containing the sequences for the process")
226 """returns the schedule which has been added to the Process or None if none have been added"""
227 return self.__schedule
229 if label ==
"schedule":
232 self.
_place(label, sch, self.__partialschedules)
241 raise RuntimeError(
"The path at index "+str(index)+
" in the Schedule was not attached to the process.")
243 self.__dict__[
'_Process__schedule'] = sch
244 schedule = property(schedule_,setSchedule_,doc=
'the schedule or None if not set')
246 """returns a dict of the services which have been added to the Process"""
248 services = property(services_,doc=
"dictionary containing the services for the process")
250 """returns a dict of the esproducers which have been added to the Process"""
252 es_producers = property(es_producers_,doc=
"dictionary containing the es_producers for the process")
254 """returns a the es_sources which have been added to the Process"""
256 es_sources = property(es_sources_,doc=
"dictionary containing the es_sources for the process")
258 """returns a dict of the es_prefers which have been added to the Process"""
260 es_prefers = property(es_prefers_,doc=
"dictionary containing the es_prefers for the process")
262 """returns a dict of the aliases that have been added to the Process"""
264 aliases = property(aliases_,doc=
"dictionary containing the aliases for the process")
266 """returns a dict of the PSets which have been added to the Process"""
268 psets = property(psets_,doc=
"dictionary containing the PSets for the process")
270 """returns a dict of the VPSets which have been added to the Process"""
272 vpsets = property(vpsets_,doc=
"dictionary containing the PSets for the process")
275 if not object.hasLabel_() :
276 object.setLabel(newLabel)
278 if newLabel == object.label_() :
280 if newLabel
is None :
281 object.setLabel(
None)
283 if (hasattr(self, object.label_())
and id(getattr(self, object.label_())) == id(object)) :
284 msg100 =
"Attempting to change the label of an attribute of the Process\n"
285 msg101 =
"Old label = "+object.label_()+
" New label = "+newLabel+
"\n"
286 msg102 =
"Type = "+str(type(object))+
"\n"
287 msg103 =
"Some possible solutions:\n"
288 msg104 =
" 1. Clone modules instead of using simple assignment. Cloning is\n"
289 msg105 =
" also preferred for other types when possible.\n"
290 msg106 =
" 2. Declare new names starting with an underscore if they are\n"
291 msg107 =
" for temporaries you do not want propagated into the Process. The\n"
292 msg108 =
" underscore tells \"from x import *\" and process.load not to import\n"
293 msg109 =
" the name.\n"
294 msg110 =
" 3. Reorganize so the assigment is not necessary. Giving a second\n"
295 msg111 =
" name to the same object usually causes confusion and problems.\n"
296 msg112 =
" 4. Compose Sequences: newName = cms.Sequence(oldName)\n"
297 raise ValueError(msg100+msg101+msg102+msg103+msg104+msg105+msg106+msg107+msg108+msg109+msg110+msg111+msg112)
298 object.setLabel(
None)
299 object.setLabel(newLabel)
303 if not name.replace(
'_',
'').isalnum():
304 raise ValueError(
'The label '+name+
' contains forbiden characters')
307 if name.startswith(
'_Process__'):
308 self.__dict__[name]=value
310 if not isinstance(value,_ConfigureComponent):
311 raise TypeError(
"can only assign labels to an object which inherits from '_ConfigureComponent'\n"
312 +
"an instance of "+str(type(value))+
" will not work")
313 if not isinstance(value,_Labelable)
and not isinstance(value,Source)
and not isinstance(value,Looper)
and not isinstance(value,Schedule):
314 if name == value.type_():
318 raise TypeError(
"an instance of "+str(type(value))+
" can not be assigned the label '"+name+
"'.\n"+
319 "Please either use the label '"+value.type_()+
" or use the 'add_' method instead.")
322 newValue =value.copy()
324 newValue._filename = value._filename
330 if not self.
_okToPlace(name, value, self.__dict__):
331 newFile=
'top level config'
332 if hasattr(value,
'_filename'):
333 newFile = value._filename
334 oldFile=
'top level config'
335 oldValue = getattr(self,name)
336 if hasattr(oldValue,
'_filename'):
337 oldFile = oldValue._filename
338 msg =
"Trying to override definition of process."+name
339 msg +=
"\n new object defined in: "+newFile
340 msg +=
"\n existing object defined in: "+oldFile
341 raise ValueError(msg)
343 if hasattr(self,name)
and not (getattr(self,name)==newValue):
347 if isinstance(newValue, _Sequenceable):
348 if not self.__InExtendCall:
352 newFile=
'top level config'
353 if hasattr(value,
'_filename'):
354 newFile = value._filename
355 oldFile=
'top level config'
356 oldValue = getattr(self,name)
357 if hasattr(oldValue,
'_filename'):
358 oldFile = oldValue._filename
359 msg1 =
"Trying to override definition of "+name+
" while it is used by the sequence "
360 msg2 =
"\n new object defined in: "+newFile
361 msg2 +=
"\n existing object defined in: "+oldFile
364 raise ValueError(msg1+s.label_()+msg2)
367 raise ValueError(msg1+s.label_()+msg2)
370 raise ValueError(msg1+s.label_()+msg2)
372 self.__dict__[name]=newValue
373 if isinstance(newValue,_Labelable):
375 self._cloneToObjectDict[id(value)] = newValue
376 self._cloneToObjectDict[id(newValue)] = newValue
378 newValue._place(name,self)
380 """Given a container of sequences, find the first sequence containing mod
381 and return the sequence. If no sequence is found, return None"""
383 for sequenceable
in seqs.itervalues():
386 sequenceable.visit(v)
391 if not hasattr(self,name):
392 raise KeyError(
'process does not know about '+name)
393 elif name.startswith(
'_Process__'):
394 raise ValueError(
'this attribute cannot be deleted')
399 if reg.has_key(name): del reg[name]
401 obj = getattr(self,name)
402 if isinstance(obj,_Labelable):
403 getattr(self,name).setLabel(
None)
406 del self.__dict__[name]
411 """Allows addition of components which do not have to have a label, e.g. Services"""
412 if not isinstance(value,_ConfigureComponent):
414 if not isinstance(value,_Unlabelable):
419 newValue =value.copy()
423 newValue._place(
'',self)
426 if not self.__InExtendCall:
437 if d[name]._isModified:
448 if self.
__isStrict and isinstance(mod, _ModuleSequenceType):
449 d[name] = mod._postProcessFixup(self._cloneToObjectDict)
452 if isinstance(mod,_Labelable):
455 self.
_place(name, mod, self.__outputmodules)
457 self.
_place(name, mod, self.__producers)
459 self.
_place(name, mod, self.__filters)
461 self.
_place(name, mod, self.__analyzers)
465 self.
_place(name, mod, self.__paths)
466 except ModuleCloneError, msg:
468 raise Exception(
"%sThe module %s in path %s is unknown to the process %s." %(context, msg, name, self._Process__name))
472 self.
_place(name, mod, self.__endpaths)
473 except ModuleCloneError, msg:
475 raise Exception(
"%sThe module %s in endpath %s is unknown to the process %s." %(context, msg, name, self._Process__name))
478 self.
_place(name, mod, self.__sequences)
480 self.
_place(name, mod, self.__esproducers)
482 self.
_place(name, mod, self.__esprefers)
484 self.
_place(name, mod, self.__essources)
486 self.
_place(name, mod, self.__aliases)
488 self.
_place(name, mod, self.__psets)
490 self.
_place(name, mod, self.__vpsets)
492 """Allow the source to be referenced by 'source' or by type name"""
494 raise ValueError(
"The label '"+name+
"' can not be used for a Source. Only 'source' is allowed.")
495 if self.__dict__[
'_Process__source']
is not None :
496 del self.__dict__[self.__dict__[
'_Process__source'].type_()]
497 self.__dict__[
'_Process__source'] = mod
498 self.__dict__[mod.type_()] = mod
501 raise ValueError(
"The label '"+name+
"' can not be used for a Looper. Only 'looper' is allowed.")
502 self.__dict__[
'_Process__looper'] = mod
503 self.__dict__[mod.type_()] = mod
505 if name !=
'subProcess':
506 raise ValueError(
"The label '"+name+
"' can not be used for a SubProcess. Only 'subProcess' is allowed.")
507 self.__dict__[
'_Process__subProcess'] = mod
508 self.__dict__[mod.type_()] = mod
510 self.
_place(typeName, mod, self.__services)
511 self.__dict__[typeName]=mod
513 moduleName = moduleName.replace(
"/",
".")
514 module = __import__(moduleName)
515 self.
extend(sys.modules[moduleName])
517 """Look in other and find types which we can use"""
519 self.__dict__[
'_Process__InExtendCall'] =
True
522 for name
in dir(other):
524 if name.startswith(
'_'):
526 item = getattr(other,name)
527 if name ==
"source" or name ==
"looper" or name ==
"subProcess":
529 elif isinstance(item,_ModuleSequenceType):
531 elif isinstance(item,_Labelable):
533 if not item.hasLabel_() :
535 elif isinstance(item,Schedule):
537 elif isinstance(item,_Unlabelable):
541 for name
in seqs.iterkeys():
545 if id(seq)
not in self._cloneToObjectDict:
548 newSeq = self._cloneToObjectDict[id(seq)]
549 self.__dict__[name]=newSeq
552 newSeq._place(name,self)
553 self.__dict__[
'_Process__InExtendCall'] =
False
555 for m
in self.__modifiers:
556 m._applyNewProcessModifiers(self)
560 for name,item
in items:
561 returnValue +=options.indentation()+typeName+
' '+name+
' = '+item.dumpConfig(options)
565 for name,item
in items:
566 returnValue +=options.indentation()+typeName+
' = '+item.dumpConfig(options)
570 for name,item
in items:
571 if name == item.type_():
573 returnValue +=options.indentation()+typeName+
' '+name+
' = '+item.dumpConfig(options)
576 """return a string containing the equivalent process defined using the old configuration language"""
577 config =
"process "+self.__name+
" = {\n"
622 for name,item
in self.psets.iteritems():
623 config +=options.indentation()+item.configTypeName()+
' '+name+
' = '+item.configValue(options)
624 for name,item
in self.vpsets.iteritems():
625 config +=options.indentation()+
'VPSet '+name+
' = '+item.configValue(options)
627 pathNames = [p.label_()
for p
in self.
schedule]
628 config +=options.indentation()+
'schedule = {'+
','.
join(pathNames)+
'}\n'
639 result +=options.indentation()+
'es_prefer '+item.targetLabel_()+
' = '+item.dumpConfig(options)
644 for name,item
in d.items():
645 returnValue +=
'process.'+name+
' = '+item.dumpPython(options)+
'\n\n'
647 for name,item
in sorted(d.items()):
648 returnValue +=
'process.'+name+
' = '+item.dumpPython(options)+
'\n\n'
655 sequence.visit(nameVisitor)
657 raise RuntimeError(
"An entry in sequence "+label +
' has no label')
662 for label,seq
in self.sequences.iteritems():
666 dependencies[label]=[dep.label_()
for dep
in d
if dep.hasLabel_()]
667 resolvedDependencies=
True
671 while resolvedDependencies:
673 resolvedDependencies = (0 != len(dependencies))
674 oldDeps =
dict(dependencies)
675 for label,deps
in oldDeps.iteritems():
677 if len(deps)==0
or iterCount > 100:
679 resolvedDependencies=
True
682 del dependencies[label]
683 for lb2,deps2
in dependencies.iteritems():
684 while deps2.count(label):
686 if len(dependencies):
687 raise RuntimeError(
"circular sequence dependency discovered \n"+
688 ",".
join([label
for label,junk
in dependencies.iteritems()]))
692 for name, value
in d.iteritems():
693 result += value.dumpPythonAs(name,options)+
'\n'
696 """return a string containing the equivalent process defined using python"""
697 result =
"import FWCore.ParameterSet.Config as cms\n\n"
698 result +=
"process = cms.Process(\""+self.__name+
"\")\n\n"
720 pathNames = [
'process.'+p.label_()
for p
in self.
schedule]
721 result +=
'process.schedule = cms.Schedule(*[ ' +
', '.
join(pathNames) +
' ])\n'
725 old = getattr(self,label)
727 for sequenceable
in self.sequences.itervalues():
728 sequenceable.replace(old,new)
729 for sequenceable
in self.paths.itervalues():
730 sequenceable.replace(old,new)
731 for sequenceable
in self.endpaths.itervalues():
732 sequenceable.replace(old,new)
734 """ Replace the item with label 'label' by object 'new' in the process and all sequences/paths"""
735 if not hasattr(self,label):
736 raise LookupError(
"process has no item of label "+label)
738 setattr(self,label,new)
740 for name,value
in itemDict.iteritems():
741 value.insertInto(parameterSet, name)
745 newlabel = item.nameInProcessDesc_(label)
747 item.insertInto(parameterSet, newlabel)
748 parameterSet.addVString(tracked, label, vitems)
751 for name,value
in itemDict.iteritems():
752 newLabel = value.nameInProcessDesc_(name)
754 value.insertInto(parameterSet, name)
757 parameterSet.addVString(tracked, label, l)
764 for name,value
in self.
paths_().iteritems():
765 scheduledPaths.append(name)
766 triggerPaths.append(name)
767 for name,value
in self.
endpaths_().iteritems():
768 scheduledPaths.append(name)
769 endpaths.append(name)
772 pathname = path.label_()
773 scheduledPaths.append(pathname)
775 endpaths.append(pathname)
777 triggerPaths.append(pathname)
778 processPSet.addVString(
True,
"@end_paths", endpaths)
779 processPSet.addVString(
True,
"@paths", scheduledPaths)
781 p = processPSet.newPSet()
782 p.addVString(
True,
"@trigger_paths", triggerPaths)
783 processPSet.addPSet(
True,
"@trigger_paths", p)
787 for triggername
in triggerPaths:
789 pathValidator.setLabel(triggername)
791 self.
paths_()[triggername].insertInto(processPSet, triggername, self.__dict__)
792 for endpathname
in endpaths:
794 endpathValidator.setLabel(endpathname)
796 self.
endpaths_()[endpathname].insertInto(processPSet, endpathname, self.__dict__)
797 processPSet.addVString(
False,
"@filters_on_endpaths", endpathValidator.filtersOnEndpaths)
800 """ Remove clutter from the process which we think is unnecessary:
801 tracked PSets, VPSets and unused modules and sequences. If a Schedule has been set, then Paths and EndPaths
802 not in the schedule will also be removed, along with an modules and sequences used only by
803 those removed Paths and EndPaths."""
812 for x
in self.paths.itervalues():
813 x.resolve(self.__dict__)
814 for x
in self.endpaths.itervalues():
815 x.resolve(self.__dict__)
817 unneededPaths = set()
819 usedModules=set(self.
schedule_().moduleNames())
821 schedNames = set(( x.label_()
for x
in self.
schedule_()))
822 names = set(self.
paths)
824 unneededPaths = names - schedNames
825 for n
in unneededPaths:
828 pths =
list(self.paths.itervalues())
829 pths.extend(self.endpaths.itervalues())
831 usedModules=set(temp.moduleNames())
838 for p
in self.paths.itervalues():
840 for p
in self.endpaths.itervalues():
842 keepSeqSet = set(( s
for s
in seqs
if s.hasLabel_()))
843 availableSeqs = set(self.sequences.itervalues())
844 unneededSeqs = availableSeqs-keepSeqSet
845 unneededSeqLabels = []
846 for s
in unneededSeqs:
847 unneededSeqLabels.append(s.label_())
848 delattr(self,s.label_())
850 print "prune removed the following:"
851 print " modules:"+
",".
join(unneededModules)
852 print " sequences:"+
",".
join(unneededSeqLabels)
853 print " paths/endpaths:"+
",".
join(unneededPaths)
855 moduleNames = set(d.keys())
856 junk = moduleNames - scheduledNames
862 """Used by the framework to convert python to C++ objects"""
863 class ServiceInjectorAdaptor(
object):
867 def addService(self,pset):
868 self.__thelist.append(pset)
870 return self.__processPSet.newPSet()
874 class TopLevelPSetAcessorAdaptor(
object):
878 def __getattr__(self,attr):
879 return getattr(self.
__ppset,attr)
880 def getTopPSet_(self,label):
883 return TopLevelPSetAcessorAdaptor(self.__ppset.newPSet(),self.
__process)
884 def addPSet(self,tracked,name,ppset):
885 return self.__ppset.addPSet(tracked,name,self.__extractPSet(ppset))
886 def addVPSet(self,tracked,name,vpset):
887 return self.__ppset.addVPSet(tracked,name,[self.__extractPSet(x)
for x
in vpset])
888 def __extractPSet(self,pset):
889 if isinstance(pset,TopLevelPSetAcessorAdaptor):
894 processPSet.addString(
True,
"@process_name", self.
name_())
899 adaptor = TopLevelPSetAcessorAdaptor(processPSet,self)
914 getattr(self,n).insertInto(ServiceInjectorAdaptor(adaptor,services))
915 adaptor.addVPSet(
False,
"services",services)
925 def prefer(self, esmodule,*args,**kargs):
926 """Prefer this ES source or producer. The argument can
927 either be an object label, e.g.,
928 process.prefer(process.juicerProducer) (not supported yet)
929 or a name of an ESSource or ESProducer
930 process.prefer("juicer")
931 or a type of unnamed ESSource or ESProducer
932 process.prefer("JuicerProducer")
933 In addition, you can pass as a labelled arguments the name of the Record you wish to
934 prefer where the type passed is a cms.vstring and that vstring can contain the
935 name of the C++ types in the Record which are being preferred, e.g.,
936 #prefer all data in record 'OrangeRecord' from 'juicer'
937 process.prefer("juicer", OrangeRecord=cms.vstring())
939 #prefer only "Orange" data in "OrangeRecord" from "juicer"
940 process.prefer("juicer", OrangeRecord=cms.vstring("Orange"))
942 #prefer only "Orange" data with label "ExtraPulp" in "OrangeRecord" from "juicer"
943 ESPrefer("ESJuicerProd", OrangeRecord=cms.vstring("Orange/ExtraPulp"))
946 if isinstance(esmodule, ESSource)
or isinstance(esmodule, ESProducer):
947 raise RuntimeError(
"Syntax of process.prefer(process.esmodule) not supported yet")
948 elif self._findPreferred(esmodule, self.es_producers_(),*args,**kargs)
or \
949 self._findPreferred(esmodule, self.es_sources_(),*args,**kargs):
952 raise RuntimeError(
"Cannot resolve prefer for "+repr(esmodule))
957 typ = d[esname].type_()
966 for name, value
in d.iteritems():
967 if value.type_() == esname:
969 raise RuntimeError(
"More than one ES module for "+esname)
975 """a dictionary with fixed keys"""
977 raise AttributeError,
"An FilteredStream defintion cannot be modified after creation."
978 _blocked_attribute = property(_blocked_attribute)
979 __setattr__ = __delitem__ = __setitem__ = clear = _blocked_attribute
980 pop = popitem = setdefault = update = _blocked_attribute
982 new = dict.__new__(cls)
983 dict.__init__(new, *args, **kw)
986 if keys != [
'content',
'dataTier',
'name',
'paths',
'responsible',
'selectEvents']:
987 raise ValueError(
"The needed parameters are: content, dataTier, name, paths, responsible, selectEvents")
988 if not isinstance(kw[
'name'],str):
989 raise ValueError(
"name must be of type string")
990 if not isinstance(kw[
'content'], vstring)
and not isinstance(kw[
'content'],str):
991 raise ValueError(
"content must be of type vstring or string")
992 if not isinstance(kw[
'dataTier'], string):
993 raise ValueError(
"dataTier must be of type string")
994 if not isinstance(kw[
'selectEvents'], PSet):
995 raise ValueError(
"selectEvents must be of type PSet")
996 if not isinstance(kw[
'paths'],(tuple, Path)):
997 raise ValueError(
"'paths' must be a tuple of paths")
1002 return "FilteredStream object: %s" %self[
"name"]
1007 """Allows embedding another process within a parent process. This allows one to
1008 chain processes together directly in one cmsRun job rather than having to run
1009 separate jobs which are connected via a temporary file.
1011 def __init__(self,process, SelectEvents = untracked.PSet(), outputCommands = untracked.vstring()):
1014 if not isinstance(process, Process):
1015 raise ValueError(
"the 'process' argument must be of type cms.Process")
1016 if not isinstance(SelectEvents,PSet):
1017 raise ValueError(
"the 'SelectEvents' argument must be of type cms.untracked.PSet")
1018 if not isinstance(outputCommands,vstring):
1019 raise ValueError(
"the 'outputCommands' argument must be of type cms.untracked.vstring")
1024 out =
"parentProcess"+str(
hash(self))+
" = process\n"
1025 out += self.__process.dumpPython()
1026 out +=
"childProcess = process\n"
1027 out +=
"process = parentProcess"+str(
hash(self))+
"\n"
1028 out +=
"process.subProcess = cms.SubProcess( process = childProcess, SelectEvents = "+self.__SelectEvents.dumpPython(options) +
", outputCommands = "+self.__outputCommands.dumpPython(options) +
")\n"
1033 return '@sub_process'
1035 process._placeSubProcess(
'subProcess',self)
1037 topPSet = parameterSet.newPSet()
1038 self.__process.fillProcessDesc(topPSet)
1039 subProcessPSet = parameterSet.newPSet()
1040 self.__SelectEvents.insertInto(subProcessPSet,
"SelectEvents")
1041 self.__outputCommands.insertInto(subProcessPSet,
"outputCommands")
1042 subProcessPSet.addPSet(
False,
"process",topPSet)
1046 """Helper class for Modifier which takes key/value pairs and uses them to reset parameters of the object"""
1050 for k,v
in self.__args.iteritems():
1054 """This class is used to define standard modifications to a Process.
1055 An instance of this class is declared to denote a specific modification,e.g. era2017 could
1056 reconfigure items in a process to match our expectation of running in 2017. Once declared,
1057 these Modifier instances are imported into a configuration and items which need to be modified
1058 are then associated with the Modifier and with the action to do the modification.
1059 The registered modifications will only occur if the Modifier was passed to
1060 the cms.Process' constructor.
1066 """This is used to register actions to be performed on the process as a whole.
1067 This takes as argument a callable object (e.g. function) which takes as its sole argument an instance of Process"""
1068 self.__processModifiers.append(func)
1070 """This is used to register an action to be performed on the specific object. Two different forms are allowed
1071 Form 1: A callable object (e.g. function) can be passed as the second. This callable object is expected to take one argument
1072 which will be the object passed in as the first argument.
1073 Form 2: A list of parameter name, value pairs can be passed
1074 mod.toModify(foo, fred=cms.int32(7), barney = cms.double(3.14))
1076 if func
is not None and len(kw) != 0:
1077 raise TypeError(
"toModify takes either two arguments or one argument and key/value pairs")
1080 if func
is not None:
1086 """Should only be called by cms.Process instances
1087 applies list of accumulated changes to the process"""
1092 """Should only be called by cms.Process instances"""
1098 """A Modifier made up of a list of Modifiers
1104 """Should only be called by cms.Process instances
1105 applies list of accumulated changes to the process"""
1107 m._applyNewProcessModifiers(process)
1109 """Should only be called by cms.Process instances"""
1117 if __name__==
"__main__":
1122 """Has same interface as the C++ object which creates PSets
1127 self.
values[label]=(tracked,value)
1185 """Nothing to do """
1189 self.assertEqual(len(p.parameterNames_()),0)
1191 self.assert_(
'a' in p.parameterNames_())
1192 self.assertEqual(p.a.value(), 1)
1194 self.assertEqual(p.a.value(), 10)
1196 self.assertEqual(p.a.value(), 1)
1197 self.failIf(p.a.isTracked())
1198 p.a = untracked.int32(1)
1199 self.assertEqual(p.a.value(), 1)
1200 self.failIf(p.a.isTracked())
1202 self.assertEqual(p.foo.value(), 10)
1203 self.assertEqual(p.bar.value(),1.0)
1204 self.failIf(p.bar.isTracked())
1205 self.assertRaises(TypeError,setattr,(p,
'c',1))
1207 self.assertEqual(p.a.foo.value(),10)
1208 self.assertEqual(p.a.bar.value(),1.0)
1210 self.assertEqual(p.b.fii.value(),1)
1211 self.failIf(p.b.isTracked())
1216 self.assertEqual(p.a.value(),11)
1218 self.assertEqual(p.a.value(),12)
1219 self.assertEqual(v.value(),12)
1225 self.assertNotEqual(p.b,other.b)
1230 self.assert_(
'a' in p.analyzers_() )
1231 self.assert_(
'a' in p.analyzers)
1232 p.add_(
Service(
"MessageLogger"))
1233 self.assert_(
'MessageLogger' in p.services_())
1234 self.assertEqual(p.MessageLogger.type_(),
"MessageLogger")
1236 self.assert_(
'Tracer' in p.services_())
1237 self.assertRaises(TypeError, setattr, *(p,
'b',
"this should fail"))
1238 self.assertRaises(TypeError, setattr, *(p,
'bad',
Service(
"MessageLogger")))
1239 self.assertRaises(ValueError, setattr, *(p,
'bad',
Source(
"PoolSource")))
1241 self.assertEqual(p.out.type_(),
'Outer')
1242 self.assert_(
'out' in p.outputModules_() )
1245 self.assert_(
'geom' in p.es_sources_())
1247 self.assert_(
'ConfigDB' in p.es_sources_())
1250 self.assert_(
'aliasfoo1' in p.aliases_())
1255 for name
in args.iterkeys():
1256 self.__dict__[name]=args[name]
1275 self.assertEqual(p.a.type_(),
"MyAnalyzer")
1276 self.assertEqual(p.a.label_(),
"a")
1277 self.assertRaises(AttributeError,getattr,p,
'b')
1278 self.assertEqual(p.Full.type_(),
"Full")
1279 self.assertEqual(str(p.c),
'a')
1280 self.assertEqual(str(p.d),
'a')
1295 self.assertRaises(ValueError, p1.extend, z1)
1304 aaa=copy.deepcopy(a),
1305 s4=copy.deepcopy(s3),
1312 self.assertEqual(p2.s4.label_(),
"s4")
1314 self.assertRaises(ValueError, p2.s4.setLabel,
"foo")
1315 p2.s4.setLabel(
"s4")
1316 p2.s4.setLabel(
None)
1317 p2.s4.setLabel(
"foo")
1318 p2._Process__setObjectLabel(p2.s4,
"foo")
1319 p2._Process__setObjectLabel(p2.s4,
None)
1320 p2._Process__setObjectLabel(p2.s4,
"bar")
1332 """import FWCore.ParameterSet.Config as cms
1334 process = cms.Process("test")
1336 process.a = cms.EDAnalyzer("MyAnalyzer")
1339 process.s = cms.Sequence(process.a)
1342 process.r = cms.Sequence(process.s)
1345 process.p = cms.Path(process.a)
1348 process.p2 = cms.Path(process.s)
1351 process.schedule = cms.Schedule(*[ process.p2, process.p ])
1364 """import FWCore.ParameterSet.Config as cms
1366 process = cms.Process("test")
1368 process.a = cms.EDAnalyzer("MyAnalyzer")
1371 process.b = cms.EDAnalyzer("YourAnalyzer")
1374 process.r = cms.Sequence(process.a)
1377 process.s = cms.Sequence(process.r)
1380 process.p = cms.Path(process.a)
1383 process.p2 = cms.Path(process.r)
1386 process.schedule = cms.Schedule(*[ process.p2, process.p ])
1398 """import FWCore.ParameterSet.Config as cms
1400 process = cms.Process("test")
1402 process.a = cms.EDAnalyzer("MyAnalyzer")
1405 process.r = cms.Sequence((process.a))
1408 process.p = cms.Path(process.a)
1411 process.p2 = cms.Path(process.r)
1414 process.schedule = cms.Schedule(*[ process.p2, process.p ])
1420 self.assertEqual(p.dumpPython().
replace(
'\n',
''),
'import FWCore.ParameterSet.Config as cmsprocess = cms.Process("test")process.a = cms.SecSource("MySecSource")')
1428 p.p =
Path(p.c+p.s+p.a)
1430 p.globalReplace(
"a",new)
1438 self.assertEqual(str(p.s),
'a+b')
1439 self.assertEqual(p.s.label_(),
's')
1440 path =
Path(p.c+p.s)
1441 self.assertEqual(str(path),
'c+a+b')
1442 p._validateSequence(path,
'p1')
1444 p2 =
Path(p.c+p.s*notInProcess)
1445 self.assertRaises(RuntimeError, p._validateSequence, p2,
'p2')
1455 self.assertRaises(ValueError, p.__setattr__,
"y", testseq)
1465 self.assertEqual(str(path),
'a+b+c')
1466 path =
Path(p.a*p.b+p.c)
1467 self.assertEqual(str(path),
'a+b+c')
1470 path =
Path(p.a+ p.b*p.c)
1471 self.assertEqual(str(path),
'a+b+c')
1472 path =
Path(p.a*(p.b+p.c))
1473 self.assertEqual(str(path),
'a+b+c')
1474 path =
Path(p.a*(p.b+~p.c))
1475 self.assertEqual(str(path),
'a+b+~c')
1477 self.assertRaises(TypeError,Path,p.es)
1488 p.path =
Path(p.a*p.b)
1489 lookuptable = {id(a): p.a, id(b): p.b}
1493 self.assertEqual(str(path),str(p.path))
1506 self.assertEqual(s[0],p.path1)
1507 self.assertEqual(s[1],p.path2)
1509 self.assert_(
'b' in p.schedule.moduleNames())
1510 self.assert_(hasattr(p,
'b'))
1511 self.assert_(hasattr(p,
'c'))
1512 self.assert_(hasattr(p,
'd'))
1513 self.assert_(hasattr(p,
'path1'))
1514 self.assert_(hasattr(p,
'path2'))
1515 self.assert_(hasattr(p,
'path3'))
1517 self.assert_(
'b' in p.schedule.moduleNames())
1518 self.assert_(hasattr(p,
'b'))
1519 self.assert_(
not hasattr(p,
'c'))
1520 self.assert_(
not hasattr(p,
'd'))
1521 self.assert_(hasattr(p,
'path1'))
1522 self.assert_(hasattr(p,
'path2'))
1523 self.assert_(
not hasattr(p,
'path3'))
1530 self.assertRaises(RuntimeError,
lambda : p.setSchedule_(s) )
1539 self.assert_(
'a' in s.moduleNames())
1540 self.assert_(
'b' in s.moduleNames())
1541 self.assert_(
'c' in s.moduleNames())
1545 self.assert_(
'a' in s.moduleNames())
1546 self.assert_(
'b' in s.moduleNames())
1547 self.assert_(
'c' in s.moduleNames())
1556 self.assert_(p.schedule
is None)
1559 self.assertEqual(pths[keys[0]],p.path1)
1560 self.assertEqual(pths[keys[1]],p.path2)
1562 self.assert_(hasattr(p,
'a'))
1563 self.assert_(hasattr(p,
'b'))
1564 self.assert_(
not hasattr(p,
'c'))
1565 self.assert_(hasattr(p,
'path1'))
1566 self.assert_(hasattr(p,
'path2'))
1575 self.assert_(p.schedule
is None)
1578 self.assertEqual(pths[keys[1]],p.path1)
1579 self.assertEqual(pths[keys[0]],p.path2)
1586 self.assertEqual(p.modu.a.value(),1)
1587 self.assertEqual(p.modu.b.value(),2)
1592 self.assert_(
not a.isModified())
1594 self.assert_(a.isModified())
1596 self.assertEqual(p.a.a1.value(), 1)
1600 self.assertEqual(p.a.a1.value(), 2)
1609 self.assertRaises(ValueError, EDProducer,
'C', ps1, ps2)
1610 self.assertRaises(ValueError, EDProducer,
'C', ps1, a=
int32(3))
1618 p.bars.foos =
'Foosball'
1619 self.assertEqual(p.bars.foos,
InputTag(
'Foosball'))
1620 p.p =
Path(p.foos*p.bars)
1622 p.add_(
Service(
"MessageLogger"))
1628 p.prefer(
"ForceSource")
1630 self.assertEqual(p.dumpConfig(),
1632 es_module juicer = JuicerProducer {
1634 es_source = ForceSource {
1636 es_prefer = ForceSource {
1638 es_prefer juicer = JuicerProducer {
1642 p.prefer(
"juicer",fooRcd=
vstring(
"Foo"))
1643 self.assertEqual(p.dumpConfig(),
1645 es_module juicer = JuicerProducer {
1647 es_source = ForceSource {
1649 es_prefer = ForceSource {
1651 es_prefer juicer = JuicerProducer {
1659 self.assertEqual(p.dumpPython(),
1660 """import FWCore.ParameterSet.Config as cms
1662 process = cms.Process("Test")
1664 process.juicer = cms.ESProducer("JuicerProducer")
1667 process.ForceSource = cms.ESSource("ForceSource")
1670 process.prefer("ForceSource")
1672 process.prefer("juicer",
1673 fooRcd = cms.vstring('Foo')
1690 self.assertEqual(process.m.p.i.value(), 4)
1700 subProcess.p =
Path(subProcess.a)
1701 subProcess.add_(
Service(
"Foo"))
1703 d = process.dumpPython()
1704 equalD =
"""import FWCore.ParameterSet.Config as cms
1706 process = cms.Process("Parent")
1708 parentProcess = process
1709 import FWCore.ParameterSet.Config as cms
1711 process = cms.Process("Child")
1713 process.a = cms.EDProducer("A")
1716 process.p = cms.Path(process.a)
1719 process.Foo = cms.Service("Foo")
1722 childProcess = process
1723 process = parentProcess
1724 process.subProcess = cms.SubProcess( process = childProcess, SelectEvents = cms.untracked.PSet(
1726 ), outputCommands = cms.untracked.vstring())
1728 equalD = equalD.replace(
"parentProcess",
"parentProcess"+str(
hash(process.subProcess)))
1729 self.assertEqual(d,equalD)
1731 process.subProcess.insertInto(p,
"dummy")
1732 self.assertEqual((
True,[
'a']),p.values[
"@sub_process"][1].values[
"process"][1].values[
'@all_modules'])
1733 self.assertEqual((
True,[
'p']),p.values[
"@sub_process"][1].values[
"process"][1].values[
'@paths'])
1734 self.assertEqual({
'@service_type':(
True,
'Foo')}, p.values[
"@sub_process"][1].values[
"process"][1].values[
"services"][1][0].values)
1744 proc.fillProcessDesc(p)
1745 self.assertEqual((
True,1),p.values[
"ref"][1].values[
"a"])
1746 self.assertEqual((
True,1),p.values[
"ref3"][1].values[
"a"])
1747 self.assertEqual((
True,1),p.values[
"ref2"][1].values[
"a"])
1748 self.assertEqual((
True,1),p.values[
"ref2"][1].values[
"b"][1].values[
"a"])
1749 self.assertEqual((
True,1),p.values[
"ref4"][1][0].values[
"a"])
1750 self.assertEqual((
True,1),p.values[
"ref4"][1][1].values[
"a"])
1760 self.assert_(p.schedule
is None)
1763 self.assertEqual(pths[keys[0]],p.path1)
1764 self.assertEqual(pths[keys[1]],p.path2)
1766 p.pset2 = untracked.PSet(parA =
string(
"pset2"))
1768 p.vpset2 = untracked.VPSet()
1770 self.assert_(hasattr(p,
'a'))
1771 self.assert_(hasattr(p,
'b'))
1772 self.assert_(
not hasattr(p,
'c'))
1773 self.assert_(
not hasattr(p,
'd'))
1774 self.assert_(
not hasattr(p,
's'))
1775 self.assert_(hasattr(p,
'path1'))
1776 self.assert_(hasattr(p,
'path2'))
1793 p.path3 =
Path(p.b+p.s2)
1794 p.path4 =
Path(p.b+p.s3)
1795 p.schedule =
Schedule(p.path1,p.path2,p.path3)
1798 self.assertEqual(pths[keys[0]],p.path1)
1799 self.assertEqual(pths[keys[1]],p.path2)
1801 self.assert_(hasattr(p,
'a'))
1802 self.assert_(hasattr(p,
'b'))
1803 self.assert_(
not hasattr(p,
'c'))
1804 self.assert_(
not hasattr(p,
'd'))
1805 self.assert_(
not hasattr(p,
'e'))
1806 self.assert_(
not hasattr(p,
's'))
1807 self.assert_(hasattr(p,
's2'))
1808 self.assert_(
not hasattr(p,
's3'))
1809 self.assert_(hasattr(p,
'path1'))
1810 self.assert_(hasattr(p,
'path2'))
1811 self.assert_(hasattr(p,
'path3'))
1812 self.assert_(
not hasattr(p,
'path4'))
1820 self.assert_(hasattr(p,
'a'))
1821 self.assert_(hasattr(p,
'b'))
1822 self.assert_(hasattr(p,
's'))
1823 self.assert_(hasattr(p,
'pth'))
1830 m1.toModify(p.a,_mod_fred)
1831 self.assertEqual(p.a.fred.value(),2)
1833 m1.toModify(p.b, wilma = 2)
1834 self.assertEqual(p.b.wilma.value(),2)
1839 m1.toModify(p.a,_mod_fred)
1841 m1.toModify(p.b, wilma = 2)
1842 self.assertEqual(p.a.fred.value(),1)
1843 self.assertEqual(p.b.wilma.value(),1)
1848 m1.toModify(p.a, fred =
int32(2))
1849 p.b = p.a.clone(wilma =
int32(3))
1850 self.assertEqual(p.a.fred.value(),2)
1851 self.assertEqual(p.a.wilma.value(),1)
1852 self.assertEqual(p.b.fred.value(),2)
1853 self.assertEqual(p.b.wilma.value(),3)
1860 testMod = DummyMod()
1862 self.assert_(hasattr(p,
"a"))
1865 m1.toModifyProcess(_rem_a)
1867 self.assert_(
not hasattr(p,
"a"))
1872 testMod = DummyMod()
1873 m1.toModifyProcess(_rem_a)
1875 m1.toModify(p.b, fred =
int32(3))
1877 self.assert_(
not hasattr(p,
"a"))
1878 self.assertEqual(p.b.fred.value(),3)
def _dumpConfigUnnamedList
def testProcessDumpPython
def _dumpConfigOptionallyNamedList
def visit
Retrieve data from a perf suite output (sub) directory, only examines TimeSize at the moment...
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
def _sequencesInDependencyOrder
def __findFirstSequenceUsingModule
static std::string join(char **cmd)
def _applyNewProcessModifiers
def _applyNewProcessModifiers
def checkImportPermission
def testTypedParameterizable
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger list("!*","!HLTx*"if it matches 2 triggers or more) will accept the event if all the matching triggers are FAIL.It will reject the event if any of the triggers are PASS or EXCEPTION(this matches the behavior of"!*"before the partial wildcard feature was incorporated).Triggers which are in the READY state are completely ignored.(READY should never be returned since the trigger paths have been run