Inheritance diagram for DOTExport.DotProducer:

Public Member Functions
def	__call__ (self)

def	__init__ (self, data, options, shapes)

def	connectPaths (self)

def	connectTags (self)

def	getTopLevel (self)

def	makePath (self, path, endpath=False)

def	nodeLabel (self, obj)

def	nodeURL (self, obj)

def	produceLegend (self)

def	produceNodes (self)

def	producePaths (self)

def	produceServices (self)

def	produceSource (self)

def	recurseChildren (self, obj)

def	seqRecurseChildren (self, obj)

Public Attributes
	data

	endstarts

	nodes

	options

	pathends

	pathstarts

	shapes

	toplevel

Detailed Description

Definition at line 20 of file DOTExport.py.

Constructor & Destructor Documentation

def DOTExport.DotProducer.__init__	(	self,
		data,
		options,
		shapes
	)

Definition at line 21 of file DOTExport.py.

   def __init__(self,data,options,shapes):
     self.data = data
     self.options = options
     self.shapes = shapes
     self.nodes={}
     #lists of starts, ends of paths for path-endpath and source-path connections
     self.pathstarts=[]
     self.pathends=[]
     self.endstarts=[]
     self.toplevel = self.getTopLevel()
     

Member Function Documentation

def DOTExport.DotProducer.__call__ ( self )

Definition at line 242 of file DOTExport.py.

References DOTExport.DotProducer.connectPaths(), DOTExport.DotProducer.connectTags(), join(), DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, validateAlignments.ValidationJobMultiIOV.options, DOTExport.DotProducer.produceLegend(), DOTExport.DotProducer.produceNodes(), DOTExport.DotProducer.producePaths(), DOTExport.DotProducer.produceServices(), and DOTExport.DotProducer.produceSource().

   def __call__(self):
     blocks=[]
     if self.options['legend']:
       blocks += [self.produceLegend()]
     blocks += [self.producePaths()]
     if self.options['seqconnect']:
       blocks += [self.connectPaths()]
     if self.options['tagconnect']:
       blocks += [self.connectTags()]
     if self.options['source']:
       blocks += [self.produceSource()]
     if self.options['es'] or self.options['services']:
       blocks += [self.produceServices()]
     blocks += [self.produceNodes()]
     if self.data.process():
       return 'digraph configbrowse {\nsubgraph clusterProcess {\nlabel="%s\\n%s"\nfontsize=%s\nfontname="%s"\n%s\n}\n}\n' % (self.data.process().name_(),self.data._filename,self.options['font_size'],self.options['font_name'],'\n'.join(blocks))
     else:
       return 'digraph configbrowse {\nsubgraph clusterCFF {\nlabel="%s"\nfontsize=%s\nfontname="%s"\n%s\n}\n}\n' % (self.data._filename,self.options['font_size'],self.options['font_name'],'\n'.join(blocks))
   
   
 

def DOTExport.DotProducer.connectPaths ( self )

Definition at line 161 of file DOTExport.py.

References DOTExport.DotProducer.endstarts, and DOTExport.DotProducer.pathends.

Referenced by DOTExport.DotProducer.__call__().

   def connectPaths(self):
     result=''
     for p in self.pathends:
       for p2 in self.endstarts:
         result+="%s->%s\n" % (p,p2)
     return result
   

def DOTExport.DotProducer.connectTags ( self )

Definition at line 168 of file DOTExport.py.

References DOTExport.DotProducer.nodes, DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, and validateAlignments.ValidationJobMultiIOV.options.

Referenced by DOTExport.DotProducer.__call__().

   def connectTags(self):
     #if we are connecting by tag, add labelled tag joining lines
     #this doesn't have to be exclusive with sequence connection, by stylistically probably should be
     result=''
     allobjects = [self.nodes[n]['obj'] for n in self.nodes if self.nodes[n]['inpath']]
     self.data.readConnections(allobjects)
     connections = self.data.connections()
     for objects,names in connections.items():
       if self.options['taglabel']:
         result += '%s->%s[label="%s",color="%s",fontcolor="%s",fontsize=%s,fontname="%s"]\n' % (objects[0],objects[1],names[1],self.options['color_inputtag'],self.options['color_inputtag'],self.options['font_size'],self.options['font_name'])
       else:
         result += '%s->%s[color="%s"]\n' % (objects[0],objects[1],self.options['color_inputtag'])
     return result
   
   

def DOTExport.DotProducer.getTopLevel ( self )

Definition at line 32 of file DOTExport.py.

References DOTExport.DotProducer.nodeLabel(), DOTExport.DotProducer.nodes, DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, and validateAlignments.ValidationJobMultiIOV.options.

   def getTopLevel(self):
       
     #build a dictionary of available top-level objects
     all_toplevel={}
     if self.data.process():
       for tlo in self.data.children(self.data.topLevelObjects()[0]):
         children = self.data.children(tlo)
         if children:
           all_toplevel[tlo._label]=children
     else:
       #case if we have only an anonymous (non-process) file
       #pick up (modules, sequences, paths)
       for tlo in self.data.topLevelObjects():
         if self.data.type(tlo)=='Sequence':
           if 'sequences' in all_toplevel:
             all_toplevel['sequences']+=[tlo]
           else:
             all_toplevel['sequences']=[tlo]
         if self.data.type(tlo)=='Path':
           if 'paths' in all_toplevel:
             all_toplevel['paths']+=[tlo]
           else:
             all_toplevel['paths']=[tlo]
         if self.data.type(tlo) in ('EDAnalyzer','EDFilter','EDProducer','OutputModule'):
           self.nodes[self.data.label(tlo)]={'obj':tlo,'n_label':self.nodeLabel(tlo),'n_shape':self.shapes.get(self.data.type(tlo),'plaintext'),'inpath':True} 
         if self.options['services'] and self.data.type(tlo)=='Service':
           self.nodes[self.data.label(tlo)]={'obj':tlo,'n_label':self.nodeLabel(tlo),'n_shape':self.shapes.get(self.data.type(tlo),'plaintext'),'inpath':False}
         if self.options['es'] and self.data.type(tlo) in ('ESSource','ESProducer'):
           self.nodes[self.data.label(tlo)]={'obj':tlo,'n_label':self.nodeLabel(tlo),'n_shape':self.shapes.get(self.data.type(tlo),'plaintext'),'inpath':False}
     return all_toplevel      
 

def DOTExport.DotProducer.makePath	(	self,
		path,
		endpath = `False`
	)

Definition at line 105 of file DOTExport.py.

References join(), DOTExport.DotProducer.nodeLabel(), DOTExport.DotProducer.nodes, DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, validateAlignments.ValidationJobMultiIOV.options, DOTExport.DotProducer.recurseChildren(), and DOTExport.DotProducer.seqRecurseChildren().

Referenced by DOTExport.DotProducer.producePaths().

   def makePath(self,path,endpath=False):
     children = self.recurseChildren(path)
     pathlabel = self.data.label(path)
     if self.options['file']:
       pathlabel += '\\n%s:%s'%(self.data.pypackage(path),self.data.lineNumber(path))
     if endpath:
       pathresult = 'subgraph cluster%s {\nlabel="%s"\ncolor="%s"\nfontcolor="%s"\nfontname="%s"\nfontsize=%s\n' % (self.data.label(path),pathlabel,self.options['color_endpath'],self.options['color_endpath'],self.options['font_name'],self.options['font_size'])
     else:
       pathresult = 'subgraph cluster%s {\nlabel="%s"\ncolor="%s"\nfontcolor="%s"\nfontname="%s"\nfontsize=%s\n' % (self.data.label(path),pathlabel,self.options['color_path'],self.options['color_path'],self.options['font_name'],self.options['font_size'])
     if self.options['seqconnect']:
       if endpath:
         self.endstarts.append('endstart_%s'%self.data.label(path))
         self.nodes['endstart_%s'%self.data.label(path)]={'obj':path,'n_label':'Start %s'%self.data.label(path),'n_color':'grey','n_shape':'plaintext','inpath':False}
       else:
         self.pathstarts.append('start_%s'%self.data.label(path))
         self.pathends.append('end_%s'%self.data.label(path))
         self.nodes['start_%s'%self.data.label(path)]={'obj':path,'n_label':'Start %s'%self.data.label(path),'n_color':'grey','n_shape':'plaintext','inpath':False}
         self.nodes['end_%s'%self.data.label(path)]={'obj':path,'n_label':'End %s'%self.data.label(path),'n_color':'grey','n_shape':'plaintext','inpath':False}
     labels=[]
     for c in children:
       #this is also done in seqRecurseChildren, so will be duplicated
       #unncessary, but relatively cheap and saves more cff/cfg conditionals
       self.nodes[self.data.label(c)]={'obj':c,'n_label':self.nodeLabel(c),'n_shape':self.shapes.get(self.data.type(c),'plaintext'),'inpath':True}
       labels.append(self.data.label(c))
     if self.options['seqconnect']:
       pathresult += '->'.join(labels)+'\n'
     else:
       if not self.options['seq']:
         pathresult += '\n'.join(labels)+'\n'
     if self.options['seq']:
       if self.data.children(path):
         for path_child in self.data.children(path):
           pathresult += self.seqRecurseChildren(path_child)
     pathresult += '}\n'
     if len(labels)>0 and self.options['seqconnect']:
       if endpath:
         pathresult += 'endstart_%s->%s\n' % (self.data.label(path),labels[0])
       else:
         pathresult += 'start_%s->%s\n%s->end_%s\n' % (self.data.label(path),labels[0],labels[-1],self.data.label(path))
     
     return pathresult
 

def DOTExport.DotProducer.nodeLabel	(	self,
		obj
	)

Definition at line 89 of file DOTExport.py.

References DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, and validateAlignments.ValidationJobMultiIOV.options.

Referenced by DOTExport.DotProducer.getTopLevel(), DOTExport.DotProducer.makePath(), DOTExport.DotProducer.produceServices(), and DOTExport.DotProducer.seqRecurseChildren().

   def nodeLabel(self,obj):
     result = self.data.label(obj)
     if self.options['class']:
       result += '\\n%s'%self.data.classname(obj)
     if self.options['file']:
       result += '\\n%s:%s'%(self.data.pypackage(obj),self.data.lineNumber(obj))
     return result
     
     #generate an appropriate URL by replacing placeholders in baseurl

def DOTExport.DotProducer.nodeURL	(	self,
		obj
	)

Definition at line 98 of file DOTExport.py.

References DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, validateAlignments.ValidationJobMultiIOV.options, and python.rootplot.root2matplotlib.replace().

Referenced by DOTExport.DotProducer.produceNodes().

   def nodeURL(self,obj):
     classname = self.data.classname(obj)
     pypath = self.data.pypath(obj)
     pyline = self.data.lineNumber(obj)
     url = self.options['urlbase'].replace('$classname',classname).replace('$pypath',pypath).replace('$pyline',pyline)
     return url
     

def DOTExport.DotProducer.produceLegend ( self )

Return a legend subgraph using current shape and colour preferences.

Definition at line 236 of file DOTExport.py.

References DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, validateAlignments.ValidationJobMultiIOV.options, DOTExport.DotProducer.shapes, cms::DDParsingContext.shapes, and EcalLaserAnalyzer2.shapes.

Referenced by DOTExport.DotProducer.__call__().

   def produceLegend(self):
     """
     Return a legend subgraph using current shape and colour preferences.
     """
     return 'subgraph clusterLegend {\nlabel="legend"\ncolor=red\nSource->Producer->Filter->Analyzer\nService->ESSource[style=invis]\nESSource->ESProducer[style=invis]\nProducer->Filter[color="%s",label="InputTag",fontcolor="%s"]\nProducer[shape=%s]\nFilter[shape=%s]\nAnalyzer[shape=%s]\nESSource[shape=%s]\nESProducer[shape=%s]\nSource[shape=%s]\nService[shape=%s]\nsubgraph clusterLegendSequence {\nlabel="Sequence"\ncolor="%s"\nfontcolor="%s"\nProducer\nFilter\n}\n}\n' % (self.options['color_inputtag'],self.options['color_inputtag'],self.shapes['EDProducer'],self.shapes['EDFilter'],self.shapes['EDAnalyzer'],self.shapes['ESSource'],self.shapes['ESProducer'],self.shapes['Source'],self.shapes['Service'],self.options['color_sequence'],self.options['color_sequence'])
     

def DOTExport.DotProducer.produceNodes ( self )

Definition at line 226 of file DOTExport.py.

References mps_monitormerge.items, join(), DOTExport.DotProducer.nodes, DOTExport.DotProducer.nodeURL(), DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, and validateAlignments.ValidationJobMultiIOV.options.

Referenced by DOTExport.DotProducer.__call__().

   def produceNodes(self):
     result=''
     for n in self.nodes:
       self.nodes[n]['n_fontname']=self.options['font_name']
       self.nodes[n]['n_fontsize']=self.options['font_size']
       if self.options['url']:
         self.nodes[n]['n_URL']=self.nodeURL(self.nodes[n]['obj'])
       result += "%s[%s]\n" % (n,','.join(['%s="%s"' % (k[2:],v) for k,v in self.nodes[n].items() if k[0:2]=='n_']))
     return result
     

def DOTExport.DotProducer.producePaths ( self )

Definition at line 147 of file DOTExport.py.

References DOTExport.DotProducer.makePath(), Json::Path.makePath(), DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, validateAlignments.ValidationJobMultiIOV.options, DOTExport.DotProducer.seqRecurseChildren(), and DOTExport.DotProducer.toplevel.

Referenced by DOTExport.DotProducer.__call__().

   def producePaths(self):
     result=''
     if 'paths' in self.toplevel:
       for path in self.toplevel['paths']:
         result += self.makePath(path)
     if self.options['endpath']:
       if 'endpaths' in self.toplevel:
         for path in self.toplevel['endpaths']:
           result += self.makePath(path,True)
     if 'sequences' in self.toplevel:
       for seq in self.toplevel['sequences']:
         result += self.seqRecurseChildren(seq)
     return result
     

def DOTExport.DotProducer.produceServices ( self )

Definition at line 196 of file DOTExport.py.

References SiStripPI.max, DOTExport.DotProducer.nodeLabel(), DOTExport.DotProducer.nodes, DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, validateAlignments.ValidationJobMultiIOV.options, DOTExport.DotProducer.recurseChildren(), DOTExport.DotProducer.shapes, cms::DDParsingContext.shapes, EcalLaserAnalyzer2.shapes, and DOTExport.DotProducer.toplevel.

Referenced by DOTExport.DotProducer.__call__().

   def produceServices(self):
     # add service, eventsetup nodes
     # this will usually result in thousands and isn't that interesting
     servicenodes=[]
     result=''
     if self.options['es']:
       if 'essources' in self.toplevel:
         for e in self.toplevel['essources']:
           servicenodes.append(self.data.label(e))
           self.nodes[self.data.label(e)]={'obj':e,'n_label':self.nodeLabel(e), 'n_shape':self.shapes['ESSource'],'inpath':False}
       if 'esproducers' in self.toplevel:
         for e in self.toplevel['esproducers']:
           servicenodes.append(self.data.label(e))
           self.nodes[self.data.label(e)]={'obj':e,'n_label':self.nodeLabel(e), 'n_shape':self.shapes['ESProducer'],'inpath':False}
     if self.options['services']:
       if 'services' in self.toplevel:
         for s in self.toplevel['services']:
           self.servicenodes.append(self.data.label(s))
           self.nodes[self.data.label(s)]={'obj':s,'n_label':self.nodeLabel(e), 'n_shape':self.shapes['Service'],'inpath':False}
     #find the maximum path and endpath lengths for servicenode layout
     maxpath=max([len(recurseChildren(path) for path in self.toplevel.get('paths',(0,)))])
     maxendpath=max([len(recurseChildren(path) for path in self.toplevel.get('endpaths',(0,)))])
     
     #add invisible links between service nodes where necessary to ensure they only fill to the same height as the longest path+endpath
     #this constraint should only apply for link view
     for i,s in enumerate(servicenodes[:-1]):
       if not i%(maxpath+maxendpath)==(maxpath+maxendpath)-1:
         result+='%s->%s[style=invis]\n' % (s,servicenodes[i+1])
     return result
     

def DOTExport.DotProducer.produceSource ( self )

Definition at line 183 of file DOTExport.py.

References DOTExport.DotProducer.nodes, DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, validateAlignments.ValidationJobMultiIOV.options, DOTExport.DotProducer.pathstarts, DOTExport.DotProducer.shapes, cms::DDParsingContext.shapes, EcalLaserAnalyzer2.shapes, and DOTExport.DotProducer.toplevel.

Referenced by DOTExport.DotProducer.__call__().

   def produceSource(self):
     #add the source
     #if we are connecting sequences, connect it to all the path starts
     #if we are connecting sequences and have a schedule, connect it to path #0
     result=''
     if 'source' in self.toplevel:
       for s in self.toplevel['source']:
         self.nodes['source']={'obj':s,'n_label':self.data.classname(s),'n_shape':self.shapes['Source']}
         if self.options['seqconnect']:
             for p in self.pathstarts:
               result += 'source->%s\n' % (p)   
     return result
     

def DOTExport.DotProducer.recurseChildren	(	self,
		obj
	)

Definition at line 78 of file DOTExport.py.

References DOTExport.DotProducer.recurseChildren().

Referenced by DOTExport.DotProducer.makePath(), DOTExport.DotProducer.produceServices(), and DOTExport.DotProducer.recurseChildren().

   def recurseChildren(self,obj):
     result=[]
     children=self.data.children(obj)
     if children:
       for c in children:
         result += self.recurseChildren(c)
     else:
       result.append(obj)
     return result
     

def DOTExport.DotProducer.seqRecurseChildren	(	self,
		obj
	)

Definition at line 63 of file DOTExport.py.

References DOTExport.DotProducer.nodeLabel(), DOTExport.DotProducer.nodes, DTCalibrationWorker.DTCalibrationWorker.options, DTWorkflow.DTWorkflow.options, DOTExport.DotProducer.options, validateAlignments.ValidationJobMultiIOV.options, and DOTExport.DotProducer.seqRecurseChildren().

Referenced by DOTExport.DotProducer.makePath(), DOTExport.DotProducer.producePaths(), and DOTExport.DotProducer.seqRecurseChildren().

   def seqRecurseChildren(self,obj):
     children = self.data.children(obj)
     if children:
       seqlabel = self.data.label(obj)
       if self.options['file']:
         seqlabel += '\\n%s:%s' % (self.data.pypackage(obj),self.data.lineNumber(obj))
       result='subgraph clusterSeq%s {\nlabel="Sequence %s"\ncolor="%s"\nfontcolor="%s"\nfontname="%s"\nfontsize=%s\n' % (self.data.label(obj),seqlabel,self.options['color_sequence'],self.options['color_sequence'],self.options['font_name'],self.options['font_size'])
       for c in children:
         result += self.seqRecurseChildren(c)
       result+='}\n'
       return result
     else:
       self.nodes[self.data.label(obj)]={'obj':obj,'n_label':self.nodeLabel(obj),'n_shape':self.shapes.get(self.data.type(obj),'plaintext'),'inpath':True}
       return '%s\n'%self.data.label(obj)   
       