Inheritance diagram for html.Page:

Public Member Functions
def	__init__ (self, title, sampleName)

def	addPlotSet (self, section, plotSet)

def	addTable (self, section, table)

def	isEmpty (self)

def	write (self, fileName)

Private Member Functions
def	_appendColumnHeader (self, header)

def	_appendLegend (self, section)

def	_formatLegend (self)

def	_formatPlotSets (self)

def	_formatTables (self)

def	_mapSectionName (self, section)

def	_orderSets (self, keys)

Private Attributes
	_columnHeaders

	_columnHeadersIndex

	_content

	_legends

	_plotSets

	_sectionLegendIndex

	_tables

Detailed Description

Definition at line 305 of file html.py.

Constructor & Destructor Documentation

def html.Page.__init__	(	self,
		title,
		sampleName
	)

Definition at line 306 of file html.py.

     def __init__(self, title, sampleName):
         self._content = [
             '<html>',
             ' <head>',
             '  <title>%s</title>' % title,
             ' </head>',
             ' <body>',
             '  '+sampleName,
             '  <br/>',
             '  <br/>',
         ]
 
         self._plotSets = {}
         self._tables = {}
 

Member Function Documentation

def html.Page._appendColumnHeader	(	self,
		header
	)

private

Definition at line 429 of file html.py.

References html.Table._columnHeaders, html.Page._columnHeaders, html.Page._columnHeadersIndex, and str.

Referenced by html.Page._formatTables().

     def _appendColumnHeader(self, header):
         leg = ""
         if header in self._columnHeadersIndex:
             leg = self._columnHeadersIndex[header]
         else:
             leg = str(chr(ord('A')+len(self._columnHeaders)))
             self._columnHeaders.append("%s: %s" % (leg, header))
             self._columnHeadersIndex[header] = leg
         return leg
 

def html.Page._appendLegend	(	self,
		section
	)

private

Definition at line 361 of file html.py.

References html.Page._legends, html.Page._sectionLegendIndex, and html._sectionNameLegend().

Referenced by html.Page._formatPlotSets(), and html.Page._formatTables().

     def _appendLegend(self, section):
         leg = ""
         legends = _sectionNameLegend()
         if section in legends:
             if section in self._sectionLegendIndex:
                 leg = self._sectionLegendIndex[section]
             else:
                 legnum = len(self._legends)+1
                 leg = "<sup>%d</sup>" % legnum
                 leg2 = "<sup>%d)</sup>" % legnum
                 self._legends.append("%s %s" % (leg2, legends[section]))
                 self._sectionLegendIndex[section] = leg
         return leg
 

def html.Page._formatLegend ( self )

private

Definition at line 493 of file html.py.

References html.Page._legends.

     def _formatLegend(self):
         if len(self._legends) > 0:
             self._content.extend([
                 '  <br/>'
                 '  Details:</br>',
             ])
             for leg in self._legends:
                 self._content.append('  %s<br/>' % leg)
 
 

def html.Page._formatPlotSets ( self )

private

Definition at line 375 of file html.py.

References html.Page._appendLegend(), html.Page._mapSectionName(), html.Page._orderSets(), and html.Page._plotSets.

     def _formatPlotSets(self):
         self._content.extend([
             '  <table>'
             '   <tr>',
         ])
 
         fileTable = []
 
         sections = self._orderSets(self._plotSets.keys())
         for isec, section in enumerate(sections):
             leg = self._appendLegend(section)
 
             self._content.extend([
                 '   <td>%s%s</td>' % (self._mapSectionName(section), leg),
             ])
             files = [(os.path.basename(f), f) for f in self._plotSets[section]]
             for row in fileTable:
                 found = False
                 for i, (bsf, f) in enumerate(files):
                     if bsf == row[0]:
                         row.append(f)
                         found = True
                         del files[i]
                         break
                 if not found:
                     row.append(None)
             for bsf, f in files:
                 fileTable.append( [bsf] + [None]*isec + [f] )
 
         self._content.extend([
             '   </tr>',
         ])
 
         for row in fileTable:
             self._content.append('   <tr>')
             bs = row[0]
             for elem in row[1:]:
                 if elem is not None:
                     self._content.append('    <td><a href="%s">%s</a></td>' % (elem, bs))
                 else:
                     self._content.append('    <td></td>')
             self._content.append('   </tr>')
 
 
         self._content.extend([
             '  </table>',
         ])
 
         if len(fileTable):
             first_row = fileTable[0]
             self._content.extend([
               '  <a href="%s">Browse Folder</a>' % (first_row[1][0:first_row[1].rfind('/')])
             ])
 

def html.Page._formatTables ( self )

private

Definition at line 439 of file html.py.

References html.Page._appendColumnHeader(), html.Page._appendLegend(), html.Table._columnHeaders, html.Page._columnHeaders, html.Page._columnHeadersIndex, html.Page._mapSectionName(), html.Page._orderSets(), html.Page._tables, genParticles_cff.map, SiStripPI.max, and str.

     def _formatTables(self):
         def _allNone(row):
             for item in row:
                 if item is not None:
                     return False
             return True
 
         sections = self._orderSets(self._tables.keys())
         for isec, section in enumerate(sections):
             leg = self._appendLegend(section)
 
             table = self._tables[section]
             self._content.extend([
                 '  <br/>',
                 '  %s%s' % (self._mapSectionName(section), leg),
                 '  <table border="1">'
             ])
 
             # table is stored in column-row, need to transpose
             data = table.tableAsRowColumn()
 
             self._content.extend([
                 '   <tr>'
                 '   <td></td>'
             ])
             heads = table.columnHeaders()
             if max(map(lambda h: len(h), heads)) > 20:
                 heads = [self._appendColumnHeader(h) for h in heads]
             for head in heads:
                 self._content.append('    <td>%s</td>' % head)
             self._content.append('   </tr>')
 
             for irow, row in enumerate(data):
                 # Skip row if all values are non-existent
                 if _allNone(row):
                     continue
 
                 self._content.extend([
                     '   <tr>'
                     '    <td>%s</td>' % table.rowHeaders()[irow]
                 ])
                 # align the number columns to right
                 for icol, item in enumerate(row):
                     formatted = str(item) if item is not None else ""
                     self._content.append('    <td align="right">%s</td>' % formatted)
                 self._content.append('   </tr>')
 
             self._content.append('  </table>')
 
             for shortenedColumnHeader in self._columnHeaders:
                 self._content.append('  %s<br/>' % shortenedColumnHeader)
             self._columnHeaders = []
             self._columnHeadersIndex = {}
 

def html.Page._mapSectionName	(	self,
		section
	)

private

Definition at line 503 of file html.py.

Referenced by html.Page._formatPlotSets(), and html.Page._formatTables().

     def _mapSectionName(self, section):
         return _sectionNameMapOrder.get(section, section)
 

def html.Page._orderSets	(	self,
		keys
	)

private

Definition at line 506 of file html.py.

Referenced by html.Page._formatPlotSets(), and html.Page._formatTables().

     def _orderSets(self, keys):
         keys_sorted = sorted(keys)
         ret = []
         for section in _sectionNameMapOrder.keys():
             if section in keys_sorted:
                 ret.append(section)
                 keys_sorted.remove(section)
         ret.extend(keys_sorted)
         return ret
 

def html.Page.addPlotSet	(	self,
		section,
		plotSet
	)

Definition at line 321 of file html.py.

References html.Page._plotSets.

     def addPlotSet(self, section, plotSet):
         if section in self._plotSets:
             self._plotSets[section].extend(plotSet)
         else:
             self._plotSets[section] = plotSet
 

def html.Page.addTable	(	self,
		section,
		table
	)

Definition at line 327 of file html.py.

References html.Page._tables.

     def addTable(self, section, table):
         self._tables[section] = table
 

def html.Page.isEmpty ( self )

Definition at line 330 of file html.py.

References html.Page._plotSets, and html.Page._tables.

Referenced by plotting.Plot.clone().

     def isEmpty(self):
         for plotSet in six.itervalues(self._plotSets):
             if len(plotSet) > 0:
                 return False
 
         if len(self._tables) > 0:
             return False
 
         return True
 

def html.Page.write	(	self,
		fileName
	)

Definition at line 340 of file html.py.

     def write(self, fileName):
         self._legends = []
         self._sectionLegendIndex = {}
         self._columnHeaders = []
         self._columnHeadersIndex = {}
         self._formatPlotSets()
         self._formatTables()
         self._formatLegend()
 
         self._content.extend([
             ' </body>',
             '</html>',
         ])
 
         #print "Writing HTML report page", fileName
         f = open(fileName, "w")
         for line in self._content:
             f.write(line)
             f.write("\n")
         f.close()
 