gump-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bode...@apache.org
Subject svn commit: r749185 [2/3] - in /gump/live: ./ python/gump/actor/document/xdocs/ python/gump/core/model/ python/gump/core/update/ python/gump/test/ python/gump/util/process/
Date Mon, 02 Mar 2009 05:00:12 GMT
Modified: gump/live/python/gump/actor/document/xdocs/documenter.py
URL: http://svn.apache.org/viewvc/gump/live/python/gump/actor/document/xdocs/documenter.py?rev=749185&r1=749184&r2=749185&view=diff
==============================================================================
--- gump/live/python/gump/actor/document/xdocs/documenter.py (original)
+++ gump/live/python/gump/actor/document/xdocs/documenter.py Mon Mar  2 05:00:11 2009
@@ -6,9 +6,9 @@
 # The ASF licenses this file to You under the Apache License, Version 2.0
 # (the "License"); you may not use this file except in compliance with
 # the License.  You may obtain a copy of the License at
-# 
+#
 #     http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,665 +20,711 @@
     XDOC generation.
 """
 
-import socket
-import time
 import os
+import StringIO
 import sys
-import logging
-from string import lower,replace
-from xml.sax.saxutils import escape
+import time
 
 from shutil import copyfile
+from xml.sax.saxutils import escape
 
 from gump import log
-from gump.core.config import *
 from gump.actor.document.documenter import Documenter
 from gump.actor.document.text.documenter import TextDocumenter
-from gump.actor.document.xdocs.xdoc import *
-from gump.actor.document.xdocs.resolver import *
-from gump.util import *
-from gump.util.timing import *
-from gump.util.tools import syncDirectories,copyDirectories,wipeDirectoryTree
-
+from gump.actor.document.xdocs.config import XDocConfig
+from gump.actor.document.xdocs.resolver import XDocResolver, \
+    getDepthForObject, getRelativeLocation
+from gump.actor.document.xdocs.xdoc import XDocDocument
+from gump.core.config import default, dir, setting
 from gump.core.language.path import AnnotatedPath
-
-from gump.core.model.stats import *
-from gump.core.model.project import ProjectStatistics
-from gump.core.model.state import *
-from gump.core.model.workspace import Workspace
-from gump.core.model.module import Module
-from gump.core.model.project import Project
 from gump.core.model.misc import Resultable
-
+from gump.core.model.project import Project
+from gump.core.model.repository import SCM_TYPE_CVS, SCM_TYPE_P4
+from gump.core.model.state import REASON_BUILD_FAILED, REASON_PACKAGE, \
+    REASON_UNSET, reasonDescription, STATE_COMPLETE, STATE_FAILED, \
+    STATE_PREREQ_FAILED, STATE_SUCCESS, STATE_UNSET, stateDescription, stateName
+from gump.core.model.stats import INSIGNIFICANT_DURATION, SIGNIFICANT_DURATION
+from gump.core.model.workspace import Workspace
 from gump.tool.guru.stats import StatisticsGuru
 from gump.tool.guru.xref import XRefGuru
+from gump.tool.shared.comparator import compareProjectsByFullDependeeCount
+from gump.util import createOrderedList, getBeanAttributes, gumpSafeName, \
+    inspectGarbageCollection
+from gump.util.note import Annotatable, levelName
+from gump.util.timing import getGeneralSinceDescription, secsToElapsedTimeString
+from gump.util.tools import syncDirectories, copyDirectories, wipeDirectoryTree
+from gump.util.work import CommandWorkItem, TimedWorkItem, Workable, \
+    workTypeName
 
-from gump.core.run.gumprun import *
-
-from gump.tool.shared.comparator import *
-    
 class XDocDocumenter(Documenter):
-    
+
     def __init__(self, run, dirBase, urlBase):
-        Documenter.__init__(self, run)            
-        
+        Documenter.__init__(self, run)
+
         # Configuration can be overridden to be
         # XDOCS, not the default of XHTML.
-        self.config=XDocConfig(not run.getOptions().isXDocs()) 
-        
-        resolver=XDocResolver(dirBase,urlBase,self.config)
-        self.setResolver(resolver)    
-        
+        self.config = XDocConfig(not run.getOptions().isXDocs())
+
+        resolver = XDocResolver(dirBase, urlBase, self.config)
+        self.setResolver(resolver)
+
     def prepareRun(self):
-    
+
         log.debug('--- Prepare for Documenting Results')
         # Seed with default/site skins/etc.
         self.prepareXDoc()
-        
-    def processModule(self,module):
-        verbose=self.run.getOptions().isVerbose()
-        debug=self.run.getOptions().isDebug()
-        self.documentModule(module,True)    
+
+    def processModule(self, module):
+        self.documentModule(module, True)
         self.syncObject(module)
-         
-    def processProject(self,project):
-        
-        verbose=self.run.getOptions().isVerbose()
-        debug=self.run.getOptions().isDebug()
-        self.documentProject(project,True)
-        
+
+    def processProject(self, project):
+        self.documentProject(project, True)
         self.syncObject(project)
-        
+
         # Do once every ...
         if 0 == (project.getPositionIndex() % 5):
-            self.documentBuildLog(True)  
+            self.documentBuildLog(True)
             self.syncBuildLog()
-            
+
     def documentRun(self):
-    
+
         log.debug('--- Documenting Results')
 
         # Document...
-        self.documentRunDetails()    
-        self.documentWorkspace()  
+        self.documentRunDetails()
+        self.documentWorkspace()
         self.documentEverythingElse()
-        
+
         # Once a day...
         if self.run.getOptions().isOfficial():
             self.documentStatistics()
             self.documentXRef()
-        
+
     #####################################################################
     #
     # XDocing...
     def getXDocWorkDirectory(self):
-        if hasattr(self,'workDir'): return self.workDir        
-        wdir=os.path.abspath(os.path.join(
-                    self.workspace.getBaseDirectory(),'xdocs-work'))        
+        if hasattr(self, 'workDir'):
+            return self.workDir
+        wdir = os.path.abspath(os.path.join(
+                    self.workspace.getBaseDirectory(), 'xdocs-work'))
         if self.config.isXdocs():
-            wdir=os.path.abspath(os.path.join(wdir,'content'))            
+            wdir = os.path.abspath(os.path.join(wdir, 'content'))
         if not os.path.exists(wdir):
-            os.makedirs(wdir)         
-        self.workDir=wdir        
+            os.makedirs(wdir)
+        self.workDir = wdir
         return self.workDir
-        
+
     def getXDocLogDirectory(self):
-        if hasattr(self,'logDir'): return self.logDir        
-        ldir=self.workspace.getLogDirectory()        
+        if hasattr(self, 'logDir'):
+            return self.logDir
+        ldir = self.workspace.getLogDirectory()
         if self.config.isXdocs():
-            ldir=os.path.abspath(os.path.join(ldir,'content'))            
+            ldir = os.path.abspath(os.path.join(ldir, 'content'))
         if not os.path.exists(ldir):
-            os.makedirs(ldir)            
-        self.logDir=ldir        
+            os.makedirs(ldir)
+        self.logDir = ldir
         return self.logDir
-        
+
     def getXDocTemplateDirectory(self):
-        """ Template (XDoc skin/config) """   
-        templateName='forrest'
+        """ Template (XDoc skin/config) """
+        templateName = 'forrest'
         if self.config.isXhtml():
-            templateName='xhtml'
-        fdir=os.path.abspath(os.path.join(dir.template,templateName))
+            templateName = 'xhtml'
+        fdir = os.path.abspath(os.path.join(dir.template, templateName))
         if self.config.isXdocs():
-            fdir=os.path.abspath(os.path.join(fdir,'content'))
-        return fdir  
-        
+            fdir = os.path.abspath(os.path.join(fdir, 'content'))
+        return fdir
+
     def getXDocSiteTemplateDirectory(self):
-        """ Site Template (XDoc skin/config tweaks) """    
-        templateName='site-forrest'
+        """ Site Template (XDoc skin/config tweaks) """
+        templateName = 'site-forrest'
         if self.config.isXhtml():
-            templateName='site-xhtml'
-        fdir=os.path.abspath(os.path.join(dir.template,templateName))
+            templateName = 'site-xhtml'
+        fdir = os.path.abspath(os.path.join(dir.template, templateName))
         if self.config.isXdocs():
-            fdir=os.path.abspath(os.path.join(fdir,'content'))
-        return fdir  
-    
-    def prepareXDoc(self):   
-        """ 
-        
+            fdir = os.path.abspath(os.path.join(fdir, 'content'))
+        return fdir
+
+    def prepareXDoc(self):
+        """
+
         Copy the main template (perhaps with site tweaks) to prepare
-        
-        """                
-        log.info('Prepare XDoc work with template') 
-        xdocLogDir=self.getXDocLogDirectory()
-        
+
+        """
+        log.info('Prepare XDoc work with template')
+
         # First deleted the work tree (if exists), then ensure created
-        xdocWorkDir=self.getXDocWorkDirectory()
+        xdocWorkDir = self.getXDocWorkDirectory()
         wipeDirectoryTree(xdocWorkDir)
-                    
+
         # Sync in the defaults [i.e. cleans also]
-        xdocTemplate=self.getXDocTemplateDirectory()   
-        syncDirectories(	xdocTemplate,	\
-                            xdocWorkDir,	\
-                            self.workspace)    
-                                    
-        # Copy over the local site defaults (if any)        
-        xdocSiteTemplate=self.getXDocSiteTemplateDirectory()  
+        xdocTemplate = self.getXDocTemplateDirectory()
+        syncDirectories(xdocTemplate,
+                        xdocWorkDir,
+                        self.workspace)
+
+        # Copy over the local site defaults (if any)
+        xdocSiteTemplate = self.getXDocSiteTemplateDirectory()
         if os.path.exists(xdocSiteTemplate):
-            log.info('Prepare XDoc work with *site* template')            
-            copyDirectories(xdocSiteTemplate,	\
-                            xdocWorkDir,	\
-                            self.workspace)      
-                            
-    def syncObject(self,object):                         
+            log.info('Prepare XDoc work with *site* template')
+            copyDirectories(xdocSiteTemplate,
+                            xdocWorkDir,
+                            self.workspace)
+
+    def syncObject(self, obj):
 
         # Get relative path
-        objDir=self.resolver.getDirectoryRelativePath(object).serialize()
-        
+        objDir = self.resolver.getDirectoryRelativePath(obj).serialize()
+
         # Get relative to (1) work [source] (2) log [target] & sync
-                
+
         # Move xdocs from work directory to log
-        xdocWorkDir=self.getXDocWorkDirectory()
-        logDirectory=self.getXDocLogDirectory()
-        
-        workContents=os.path.abspath(os.path.join(xdocWorkDir,objDir))
-        logContents=os.path.abspath(os.path.join(logDirectory,objDir))
-        
-        success=True
+        xdocWorkDir = self.getXDocWorkDirectory()
+        logDirectory = self.getXDocLogDirectory()
+
+        workContents = os.path.abspath(os.path.join(xdocWorkDir, objDir))
+        logContents = os.path.abspath(os.path.join(logDirectory, objDir))
+
+        success = True
         try:
-            if os.path.exists(workContents):    
+            if os.path.exists(workContents):
                 # Sync over public pages...
-                copyDirectories(workContents,logContents) 
-        except:        
-            log.error('--- Failed to sync ['+`objDir`+'] (work->log)', exc_info=1)
-            success=False
-            
-        if self.config.isXdocs():  
+                copyDirectories(workContents, logContents)
+        except:
+            log.error('--- Failed to sync [' + `objDir` + '] (work->log)',
+                      exc_info = 1)
+            success = False
+
+        if self.config.isXdocs():
             # Move contents/xdocs from work directory to log
             # (Note: Forrest has contents/X and contents/xdocs/X)
-            xdocWorkDir=os.path.abspath(os.path.join(xdocWorkDir,'xdocs'))
-            logDirectory=os.path.abspath(os.path.join(logDirectory,'xdocs'))
-        
-            workContents=os.path.abspath(os.path.join(xdocWorkDir,objDir))
-            logContents=os.path.abspath(os.path.join(logDirectory,objDir))
-        
+            xdocWorkDir = os.path.abspath(os.path.join(xdocWorkDir, 'xdocs'))
+            logDirectory = os.path.abspath(os.path.join(logDirectory, 'xdocs'))
+
+            workContents = os.path.abspath(os.path.join(xdocWorkDir, objDir))
+            logContents = os.path.abspath(os.path.join(logDirectory, objDir))
+
             try:
-                if os.path.exists(workContents):    
+                if os.path.exists(workContents):
                     # Sync over public pages...
-                    copyDirectories(workContents,logContents) 
-            except:        
-                log.error('--- Failed to sync xdocs ['+`objDir`+'] (work->log)', exc_info=1)
-                success=False    
-        
+                    copyDirectories(workContents, logContents)
+            except:
+                log.error('--- Failed to sync xdocs [' + `objDir` + \
+                              '] (work->log)', exc_info = 1)
+                success = False
+
         return success
-        
-    def syncBuildLog(self): 
-        
-        logSpec=self.resolver.getFileSpec(self.workspace, 'buildLog')
-        
-        xdocWorkDir=self.getXDocWorkDirectory()
-        logDirectory=self.getXDocLogDirectory()
-        
-        if self.config.isXdocs():  
+
+    def syncBuildLog(self):
+
+        logSpec = self.resolver.getFileSpec(self.workspace, 'buildLog')
+
+        xdocWorkDir = self.getXDocWorkDirectory()
+        logDirectory = self.getXDocLogDirectory()
+
+        if self.config.isXdocs():
             # Move contents/xdocs from work directory to log
             # (Note: Forrest has contents/X and contents/xdocs/X)
-            xdocWorkDir=os.path.abspath(os.path.join(xdocWorkDir,'xdocs'))
-            logDirectory=os.path.abspath(os.path.join(logDirectory,'xdocs'))
-                                                        
+            xdocWorkDir = os.path.abspath(os.path.join(xdocWorkDir, 'xdocs'))
+            logDirectory = os.path.abspath(os.path.join(logDirectory, 'xdocs'))
+
         # Current status
-        logSource=os.path.abspath(
-                    os.path.join(xdocWorkDir,logSpec.getDocument()))
-        logTarget=os.path.abspath(
-                    os.path.join(logDirectory,logSpec.getDocument()))
-                    
+        logSource = os.path.abspath(
+                    os.path.join(xdocWorkDir, logSpec.getDocument()))
+        logTarget = os.path.abspath(
+                    os.path.join(logDirectory, logSpec.getDocument()))
+
         # Do the transfer..
-        success=True
+        success = True
         try:
-            log.debug('Copy %s to %s' % ( logSource, logTarget))    
-            copyfile(logSource,logTarget)    
-        except:        
-            log.error('--- Failed to sync buildLog work->log', exc_info=1)
-            success=False
-        
+            log.debug('Copy %s to %s' % (logSource, logTarget))
+            copyfile(logSource, logTarget)
+        except:
+            log.error('--- Failed to sync buildLog work->log', exc_info = 1)
+            success = False
+
         return success
-        
-    #####################################################################           
+
+    #####################################################################
     #
     # Workspace Pieces
-    #      
+    #
     def documentRunDetails(self):
-               
+
         #
         # ----------------------------------------------------------------------
         #
         # Index.xml
-        # 
-        spec=self.resolver.getFileSpec(self.run)
-        
-        document=XDocDocument('Gump Run',  
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-        
-        definitionSection=document.createSection('Run Details')    
-        
+        #
+        spec = self.resolver.getFileSpec(self.run)
+
+        document = XDocDocument('Gump Run',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
+
+        definitionSection = document.createSection('Run Details')
+
         if not self.gumpSet.isFull():
             self.documentPartial(definitionSection)
 
-        definitionTable=definitionSection.createTable()
+        definitionTable = definitionSection.createTable()
         definitionTable.createEntry('Gump Run GUID', self.run.getRunGuid())
-        definitionTable.createEntry('Gump Run (Hex) GUID', self.run.getRunHexGuid())
+        definitionTable.createEntry('Gump Run (Hex) GUID',
+                                    self.run.getRunHexGuid())
         definitionTable.createEntry('Gump Version', setting.VERSION)
-        
+
         # RSS|Atom|RDF
-        self.documentXMLLinks(document, definitionTable, depth=getDepthForObject(self.workspace))       
-        
-        #rdfUrl=self.resolver.getUrl(self.workspace,'gump','.rdf')
-        #rdfArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + rdfUrl) \
-        #        .createIcon(self.resolver.getImageUrl('valid-rdf.png'), alt='[Valid Atom]') #, title='Validate my Atom feed', width='88', height='31')
-        
-        self.documentSummary(document,self.workspace.getProjectSummary())     
-        
-        dtSection=definitionSection.createSection('Dates/Times')            
-        dtTable=dtSection.createTable()        
+        self.documentXMLLinks(document, definitionTable,
+                              depth = getDepthForObject(self.workspace))
+
+        #rdfUrl = self.resolver.getUrl(self.workspace, 'gump', '.rdf')
+        #rdfArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + \
+        #                       rdfUrl)\
+        #                       .createIcon(self.resolver\
+        #                                       .getImageUrl('valid-rdf.png'),
+        #                                   alt='[Valid Atom]')
+                                           #, title='Validate my Atom feed',
+                                           #width='88', height='31')
+
+        self.documentSummary(document, self.workspace.getProjectSummary())
+
+        dtSection = definitionSection.createSection('Dates/Times')
+        dtTable = dtSection.createTable()
         dtTable.createEntry('@@DATE@@', default.date_s)
-        dtTable.createEntry('Start Date/Time (UTC)', self.run.getStart().getUtc())
+        dtTable.createEntry('Start Date/Time (UTC)',
+                            self.run.getStart().getUtc())
         dtTable.createEntry('End Date/Time (UTC)', self.run.getEnd().getUtc())
         dtTable.createEntry('Timezone', self.run.getEnvironment().getTimezone())
         dtTable.createEntry('Start Date/Time', self.run.getStart().getLocal())
         dtTable.createEntry('End Date/Time', self.run.getEnd().getLocal())
         dtTable.createEntry('Elapsed Time', self.run.getElapsedTimeString())
 
-        pythonSection=definitionSection.createSection('Python Information')            
-        pythonTable=pythonSection.createTable()
+        pythonSection = definitionSection.createSection('Python Information')
+        pythonTable = pythonSection.createTable()
         pythonTable.createEntry('Python', str(sys.version))
-        pythonTable.createEntry('Operating System (Name)', str(os.name)) 
-        tracked=inspectGarbageCollection()
+        pythonTable.createEntry('Operating System (Name)', str(os.name))
+        tracked = inspectGarbageCollection()
         if tracked:
-            pythonTable.createEntry('Garbage Collector Tracked', tracked)               
-                
-        javaSection=definitionSection.createSection('Java Information')            
-        javaTable=javaSection.createTable()
-        javaTable.createEntry('Java Command', self.run.getEnvironment().javaCommand)
-        javaproperties=self.run.getEnvironment().getJavaProperties()
+            pythonTable.createEntry('Garbage Collector Tracked', tracked)
+
+        javaSection = definitionSection.createSection('Java Information')
+        javaTable = javaSection.createTable()
+        javaTable.createEntry('Java Command',
+                              self.run.getEnvironment().javaCommand)
+        javaproperties = self.run.getEnvironment().getJavaProperties()
         if javaproperties:
-            for name in ['java.vendor', 'java.version', 'os.name', 'os.arch', 'os.version']:
+            for name in ['java.vendor', 'java.version', 'os.name', 'os.arch',
+                         'os.version']:
                 if name in javaproperties:
-                    javaTable.createEntry(name, javaproperties[name])	  
-                               
-        self.documentAnnotations(document,self.run)
-    
-    
+                    javaTable.createEntry(name, javaproperties[name])
+
+        self.documentAnnotations(document, self.run)
+
+
         #
         # RunOptions
-        #    
-        options=self.run.getOptions()
-   
-        optSection=document.createSection('Gump Run Options')
+        #
+        options = self.run.getOptions()
+
+        optSection = document.createSection('Gump Run Options')
         optSection.createParagraph(
-            """The options selected for this Gump run.""")            
-        
-        #self.documentAnnotations(document,options)        
-        
-        optTable=optSection.createTable(['Name','Value'])
-        opts=0
-               
-        descs={ 'Build':'Perform Build',
-                'XDocs':'Generate XDOCS',
-                'Statistics':'Update Statistics (to database)',
-                'Verbose':'Verbose Run',
-                'Cache':'Cache metadata (don\'t go to remote source)',
-                'Text':'Text Output',
-                'Official':'Official Run (e.g. nag notifies, etc.)',
-                'Results':'Generate Results' }
-                
+            """The options selected for this Gump run.""")
+
+        #self.documentAnnotations(document, options)
+
+        optTable = optSection.createTable(['Name', 'Value'])
+        opts = 0
+
+        descs = { 'Build':'Perform Build',
+                  'XDocs':'Generate XDOCS',
+                  'Statistics':'Update Statistics (to database)',
+                  'Verbose':'Verbose Run',
+                  'Cache':'Cache metadata (don\'t go to remote source)',
+                  'Text':'Text Output',
+                  'Official':'Official Run (e.g. nag notifies, etc.)',
+                  'Results':'Generate Results' }
+
         # iterate over this suites properties
-        for (name,value) in getBeanAttributes(options).items():
-            desc=name
+        for (name, value) in getBeanAttributes(options).items():
+            desc = name
             if descs.has_key(name):
-                desc = descs[name] + ' (' + name + ')'                
-            optTable.createEntry(desc,value)
-            opts+=1
-            
-        if not opts: optTable.createEntry('None')
-      
+                desc = descs[name] + ' (' + name + ')'
+            optTable.createEntry(desc, value)
+            opts += 1
+
+        if not opts:
+            optTable.createEntry('None')
+
         #
         # Environment
         #
-        environment=self.run.getEnvironment()
-        
-        envSection=document.createSection('Gump Environment')
+        environment = self.run.getEnvironment()
+
+        envSection = document.createSection('Gump Environment')
         envSection.createParagraph(
-            """The environment that this Gump run was within.""")     
- 
-        propertiesSection=envSection.createSection('Properties')
-        envTable=propertiesSection.createTable(['Name/Description','Value'])
-        envs=0
+            """The environment that this Gump run was within.""")
+
+        propertiesSection = envSection.createSection('Properties')
+        envTable = propertiesSection.createTable(['Name/Description', 'Value'])
+        envs = 0
         # iterate over this suites properties
-        for (name,value) in getBeanAttributes(environment).items():
-            envTable.createEntry(name,str(value))
-            envs+=1            
-        if not envs: envTable.createEntry('None')
-        
-        
-        self.documentAnnotations(document,environment)        
-        #self.documentFileList(document,environment,'Environment-level Files')        
-        self.documentWorkList(document,environment,'Environment-level Work')
-     
-        document.serialize()    
-        document=None
-       
-    def documentXMLLinks(self, document=None, table=None, rdf=True, depth=0):
+        for (name, value) in getBeanAttributes(environment).items():
+            envTable.createEntry(name, str(value))
+            envs += 1
+        if not envs:
+            envTable.createEntry('None')
+
+        self.documentAnnotations(document, environment)
+        #self.documentFileList(document, environment, 'Environment-level Files')
+        self.documentWorkList(document, environment, 'Environment-level Work')
+
+        document.serialize()
+        document = None
+
+    def documentXMLLinks(self, document = None, table = None, rdf = True,
+                         depth = 0):
         """
-        
+
         Show RSS|Atom|RDF.
-                
+
         """
         if not table:
-            table=document.createTable(['XML Description','Links'])
-            
-        rssSyndRow=table.createRow()
+            table = document.createTable(['XML Description', 'Links'])
+
+        rssSyndRow = table.createRow()
         rssSyndRow.createData().createStrong('RSS Syndication')
-        rssArea=rssSyndRow.createData()
-        rssArea.createFork('rss.xml','RSS')
-        rssUrl=self.resolver.getUrl(self.workspace,'rss','.xml')
-        rssArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + rssUrl) \
-                .createIcon(self.resolver.getImageUrl('valid-rss.png',depth), alt='[Valid RSS]') #, title='Validate my RSS feed', width='88', height='31')
-                 
-        atomSyndRow=table.createRow()
+        rssArea = rssSyndRow.createData()
+        rssArea.createFork('rss.xml', 'RSS')
+        rssUrl = self.resolver.getUrl(self.workspace, 'rss', '.xml')
+        rssArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + \
+                               rssUrl) \
+                               .createIcon(self.resolver\
+                                               .getImageUrl('valid-rss.png',
+                                                            depth),
+                                           alt = '[Valid RSS]')
+                #, title = 'Validate my RSS feed', width = '88', height = '31')
+
+        atomSyndRow = table.createRow()
         atomSyndRow.createData().createStrong('Atom Syndication')
-        atomArea=atomSyndRow.createData()
-        atomArea.createFork('atom.xml','Atom')
-        atomUrl=self.resolver.getUrl(self.workspace,'atom','.xml')
-        atomArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + atomUrl) \
-                .createIcon(self.resolver.getImageUrl('valid-atom.png',depth), alt='[Valid Atom]') #, title='Validate my Atom feed', width='88', height='31')
-        
+        atomArea = atomSyndRow.createData()
+        atomArea.createFork('atom.xml', 'Atom')
+        atomUrl = self.resolver.getUrl(self.workspace, 'atom', '.xml')
+        atomArea.createFork('http://www.feedvalidator.org/check.cgi?url=' + \
+                                atomUrl) \
+                                .createIcon(self.resolver\
+                                                .getImageUrl('valid-atom.png',
+                                                             depth),
+                                            alt = '[Valid Atom]')
+                #, title = 'Validate my Atom feed', width = '88', height = '31')
+
         if rdf:
-            rdfRow=table.createRow()
+            rdfRow = table.createRow()
             rdfRow.createData().createStrong('RDF Metadata')
-            rdfArea=rdfRow.createData()
-            rdfArea.createFork('gump.actor.rdf','RDF')
-        
-    def documentPartial(self,node):
-            notice=node.createWarning()
-            
-            notice.createText("""This output does not represent the complete workspace,
-            but part of it.         
+            rdfArea = rdfRow.createData()
+            rdfArea.createFork('gump.actor.rdf', 'RDF')
+
+    def documentPartial(self, node):
+        notice = node.createWarning()
+
+        notice.createText(
+            """This output does not represent the complete workspace,
+            but part of it.
             Only projects, and their dependents, matching this regular expression """)
-            notice.createStrong(self.gumpSet.projectexpression)
-            notice.createBreak()
-            notice.createBreak()            
-            notice.createStrong('Requested Projects: ')
-            notice.createBreak()
-            notice.createBreak()  
-            for project in self.gumpSet.projects:
-                notice.createText(project.name)
-                notice.createText(' ')
-                        
+        notice.createStrong(self.gumpSet.projectexpression)
+        notice.createBreak()
+        notice.createBreak()
+        notice.createStrong('Requested Projects: ')
+        notice.createBreak()
+        notice.createBreak()
+        for project in self.gumpSet.projects:
+            notice.createText(project.name)
+            notice.createText(' ')
+
     def documentEverythingElse(self):
-        
+
         self.documentRepositories()
         self.documentServers()
         self.documentTrackers()
-        
+
         self.documentBuildLog()
         self.documentNotesLog()
         self.documentDiffsLog()
-        
+
         self.documentProjects()
         self.documentModules()
-        
+
         self.documentPackages()
-            
+
         #
         # Document individual repositories
         #
-        for repo in self.workspace.getRepositories():            
-            if not self.gumpSet.inRepositories(repo): continue
+        for repo in self.workspace.getRepositories():
+            if not self.gumpSet.inRepositories(repo):
+                continue
             self.documentRepository(repo)
-            
+
         #
         # Document individual servers
         #
-        for server in self.workspace.getServers():            
+        for server in self.workspace.getServers():
             self.documentServer(server)
-            
+
         # Document individual trackers
-        for tracker in self.workspace.getTrackers():            
+        for tracker in self.workspace.getTrackers():
             self.documentTracker(tracker)
-            
+
         # Document individual modules
-        for module in self.gumpSet.getCompletedModules():  
+        for module in self.gumpSet.getCompletedModules():
             self.documentModule(module)
-            
+
         # Document workspace 'Text'
-        spec=self.resolver.getFileSpec(self.workspace, 'context')
-        document=XDocDocument('Context',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-        stream=StringIO.StringIO() 
-        texter=TextDocumenter(self.run,stream)  
+        spec = self.resolver.getFileSpec(self.workspace, 'context')
+        document = XDocDocument('Context',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
+        stream = StringIO.StringIO()
+        texter = TextDocumenter(self.run, stream)
         texter.document()
         stream.seek(0)
         document.createSource(stream.read())
         stream.close()
         document.serialize()
-        
+
         if not self.workspace.private:
-            # Document the workspace XML    
-            spec=self.resolver.getFileSpec(self.workspace, 'workspace_defn')
-            document=XDocDocument('Definition',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-            stream=StringIO.StringIO() 
+            # Document the workspace XML
+            spec = self.resolver.getFileSpec(self.workspace, 'workspace_defn')
+            document = XDocDocument('Definition',
+                                    spec.getFile(),
+                                    self.config,
+                                    spec.getRootPath())
+            stream = StringIO.StringIO()
             try:
-                self.workspace.dom.writexml(stream,indent='   ',newl='\n')
+                self.workspace.dom.writexml(stream, indent = '   ', newl = '\n')
             except Exception, details:
-                stream.write('Failed to XML serialize the data. ' + str(details))
+                stream.write('Failed to XML serialize the data. ' \
+                                 + str(details))
             stream.seek(0)
             document.createSource(stream.read())
             stream.close()
-            document.serialize()     
-            
-    #####################################################################           
+            document.serialize()
+
+    #####################################################################
+    #
+    # Workspace
     #
-    # Workspace 
-    #      
     def documentWorkspace(self):
-        
-        
+
+
         #
         # ----------------------------------------------------------------------
         #
         # Index.xml
         #
-        
-        spec=self.resolver.getFileSpec(self.workspace,)
-        document=XDocDocument('Workspace',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-        
-        definitionSection=document.createSection('Workspace Definition')     
-        
-        definitionTable=definitionSection.createTable()
-        definitionTable.createEntry('Workspace Name', 
-            self.workspace.getName())
+
+        spec = self.resolver.getFileSpec(self.workspace)
+        document = XDocDocument('Workspace',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
+
+        definitionSection = document.createSection('Workspace Definition')
+
+        definitionTable = definitionSection.createTable()
+        definitionTable.createEntry('Workspace Name',
+                                    self.workspace.getName())
         if self.workspace.hasDomChild('description'):
-            definitionTable.createEntry('Description', 
-                self.workspace.getDomChildValue('description'))
-        if self.workspace.hasDomChild('version'): 
-            definitionTable.createEntry('Workspace Version', 
+            definitionTable.createEntry('Description',
+                                        self.workspace\
+                                            .getDomChildValue('description'))
+        if self.workspace.hasDomChild('version'):
+            definitionTable.createEntry('Workspace Version',
                 self.workspace.getDomAttributeValue('version'))
         if not self.workspace.hasDomAttribute('version') \
             or not self.workspace.getDomAttributeValue('version') \
-                    == setting.WS_VERSION:
-            definitionTable.createEntry('Gump Preferred Workspace Version', 
+            == setting.WS_VERSION:
+            definitionTable.createEntry('Gump Preferred Workspace Version',
                                         setting.WS_VERSION)
         definitionTable.createEntry('@@DATE@@', default.date_s)
-        definitionTable.createEntry('Start Date/Time (UTC)', self.run.getStart().getUtc())
-        definitionTable.createEntry('Start Date/Time', self.run.getStart().getLocal())
-        definitionTable.createEntry('Timezone', self.run.getEnvironment().getTimezone())
-   
-            
-        rssSyndRow=definitionTable.createRow()
+        definitionTable.createEntry('Start Date/Time (UTC)',
+                                    self.run.getStart().getUtc())
+        definitionTable.createEntry('Start Date/Time',
+                                    self.run.getStart().getLocal())
+        definitionTable.createEntry('Timezone',
+                                    self.run.getEnvironment().getTimezone())
+
+
+        rssSyndRow = definitionTable.createRow()
         rssSyndRow.createData('Syndication')
-        rssSyndRow.createData().createFork('rss.xml','RSS')
-        atomSyndRow=definitionTable.createRow()
+        rssSyndRow.createData().createFork('rss.xml', 'RSS')
+        atomSyndRow = definitionTable.createRow()
         atomSyndRow.createData('Syndication')
-        atomSyndRow.createData().createFork('atom.xml','Atom')
-                
-        textRow=definitionTable.createRow()
+        atomSyndRow.createData().createFork('atom.xml', 'Atom')
+
+        textRow = definitionTable.createRow()
         textRow.createData('Workspace Documentation')
-        textRow.createData().createLink('context.html','Text')
-                
-        if not self.workspace.private:            
-            syndRow=definitionTable.createRow()
+        textRow.createData().createLink('context.html', 'Text')
+
+        if not self.workspace.private:
+            syndRow = definitionTable.createRow()
             syndRow.createData('Definition')
-            syndRow.createData().createLink('workspace_defn.html','XML')
-                                
-        self.documentAnnotations(document,self.workspace)
-        #self.documentXML(document,self.workspace)
-        
-        detailsSection=document.createSection('Details')
-                    
-        detailsTable=detailsSection.createTable()
-        detailsTable.createEntry("State : ", 
-                self.workspace.getStateDescription()) 
+            syndRow.createData().createLink('workspace_defn.html', 'XML')
+
+        self.documentAnnotations(document, self.workspace)
+        #self.documentXML(document, self.workspace)
+
+        detailsSection = document.createSection('Details')
+
+        detailsTable = detailsSection.createTable()
+        detailsTable.createEntry("State : ",
+                                 self.workspace.getStateDescription())
 
         e = self.workspace.getElapsedTimeString()
-        if e : detailsTable.createEntry("Elapsed Time : ", e)
-        detailsTable.createEntry("Base Directory : ", self.workspace.getBaseDirectory())
-        detailsTable.createEntry("Temporary Directory : ", self.workspace.tmpdir)
+        if e:
+            detailsTable.createEntry("Elapsed Time : ", e)
+        detailsTable.createEntry("Base Directory : ",
+                                 self.workspace.getBaseDirectory())
+        detailsTable.createEntry("Temporary Directory : ",
+                                 self.workspace.tmpdir)
         #if self.workspace.scratchdir:
-        #    detailsTable.createEntry("Scratch Directory : ", self.workspace.scratchdir))    
+        #    detailsTable.createEntry("Scratch Directory : ",
+        #                             self.workspace.scratchdir))
         # :TODO: We have duplicate dirs? tmp = scratch?
-        detailsTable.createEntry("Log Directory : ", self.workspace.logdir)
-        detailsTable.createEntry("Outputs Repository : ", self.workspace.repodir)
+        detailsTable.createEntry("Log Directory : ",
+                                 self.workspace.logdir)
+        detailsTable.createEntry("Outputs Repository : ",
+                                 self.workspace.repodir)
         detailsTable.createEntry("CVS Directory : ", self.workspace.cvsdir)
         detailsTable.createEntry("Package Directory : ", self.workspace.pkgdir)
         if not self.workspace.private:
-            detailsTable.createEntry("E-mail Server: ", self.workspace.mailserver)
+            detailsTable.createEntry("E-mail Server: ",
+                                     self.workspace.mailserver)
             detailsTable.createEntry("E-mail Port: ", self.workspace.mailport)
-            detailsTable.createEntry("List Address: ", self.workspace.administrator)
-            detailsTable.createEntry("E-mail Address: ", self.workspace.email)            
+            detailsTable.createEntry("List Address: ",
+                                     self.workspace.administrator)
+            detailsTable.createEntry("E-mail Address: ", self.workspace.email)
             detailsTable.createEntry("Prefix: ", self.workspace.prefix)
             detailsTable.createEntry("Signature: ", self.workspace.signature)
-        
-        self.documentStats(document,self.workspace)
-        self.documentProperties(detailsSection, self.workspace, 'Workspace Properties')
-        
+
+        self.documentStats(document, self.workspace)
+        self.documentProperties(detailsSection, self.workspace,
+                                'Workspace Properties')
+
         # Does this self.workspace send notification (nag) mails?
-        detailsTable.createEntry("Send Notification E-mails: ", `self.workspace.isNotify()`)
-        
-        detailsTable.createEntry("Multi-threading: ", `self.workspace.isMultithreading()`)
+        detailsTable.createEntry("Send Notification E-mails: ",
+                                 `self.workspace.isNotify()`)
+
+        detailsTable.createEntry("Multi-threading: ",
+                                 `self.workspace.isMultithreading()`)
         if self.workspace.isMultithreading():
-            detailsTable.createEntry("Updater Threads: ", `self.workspace.getUpdaters()`)    
-            detailsTable.createEntry("Builder Threads: ", `self.workspace.getBuilders()`)     
-        
-        #document.createRaw('<p><strong>Context Tree:</strong> <link href=\'workspace.html\'>workspace</link></p>')
-        # x.write('<p><strong>Workspace Config:</strong> <link href=\'xml.txt\'>XML</link></p>')
-        # x.write('<p><strong>RSS :</strong> <link href=\'index.rss\'>News Feed</link></p>')
-        
-        self.documentFileList(document,self.workspace,'Workspace-level Files')
-        self.documentWorkList(document,self.workspace,'Workspace-level Work')
-     
-        document.serialize()    
-        document=None
-              
-            
-    def documentRepositories(self):        
-          
+            detailsTable.createEntry("Updater Threads: ",
+                                     `self.workspace.getUpdaters()`)
+            detailsTable.createEntry("Builder Threads: ",
+                                     `self.workspace.getBuilders()`)
+
+        #document.createRaw('<p><strong>Context Tree:</strong> ' + \
+        #                       '<link href=\'workspace.html\'>workspace' + \
+        #                       '</link></p>')
+        #x.write('<p><strong>Workspace Config:</strong> ' + \
+        #            '<link href=\'xml.txt\'>XML</link></p>')
+        #x.write('<p><strong>RSS :</strong> <link href=\'index.rss\'>' + \
+        #            'News Feed</link></p>')
+
+        self.documentFileList(document, self.workspace, 'Workspace-level Files')
+        self.documentWorkList(document, self.workspace, 'Workspace-level Work')
+
+        document.serialize()
+        document = None
+
+
+    def documentRepositories(self):
+
         #
         # ----------------------------------------------------------------------
         #
         # Repositories.xml
         #
-        spec=self.resolver.getFileSpec(self.workspace, 'repositories')
-        document=XDocDocument( 'All Repositories',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-        
-        
-        reposSection=document.createSection('All Repositories')
-        reposTable=reposSection.createTable(['Name'])
-        
+        spec = self.resolver.getFileSpec(self.workspace, 'repositories')
+        document = XDocDocument('All Repositories',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
+
+
+        reposSection = document.createSection('All Repositories')
+        reposTable = reposSection.createTable(['Name'])
+
         # Pretty sorting...
-        sortedRepositoryList=createOrderedList(self.gumpSet.getRepositories())        
-        
-        rcount=0
+        sortedRepositoryList = createOrderedList(self.gumpSet.getRepositories())
+
+        rcount = 0
         for repo in sortedRepositoryList:
-            if not self.gumpSet.inRepositories(repo): continue
-            
-            rcount+=1
-                    
-            repoRow=reposTable.createRow()
+            if not self.gumpSet.inRepositories(repo):
+                continue
+
+            rcount += 1
+
+            repoRow = reposTable.createRow()
             repoRow.createComment(repo.getName())
-                       
-            self.insertLink( repo, self.workspace, repoRow.createData())
-            
-        if not rcount: reposTable.createLine('None')
-        
-        document.serialize()
-        document=None
-       
-    def documentServers(self):   
-    
+
+            self.insertLink(repo, self.workspace, repoRow.createData())
+
+        if not rcount:
+            reposTable.createLine('None')
+
+        document.serialize()
+        document = None
+
+    def documentServers(self):
+
         #
         # ----------------------------------------------------------------------
         #
         # Servers.xml
         #
-        spec=self.resolver.getFileSpec(self.workspace, 'servers')
-        document=XDocDocument( 'All Servers',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-                
-        serversSection=document.createSection('All Servers')
-        serversTable=serversSection.createTable(['Name','Status','Notes','Results','Start (Local)','Start (UTC)','End (UTC)','Offset (from UTC)'])
-
-        sortedServerList=createOrderedList(self.workspace.getServers())       
-        
-        scount=0
+        spec = self.resolver.getFileSpec(self.workspace, 'servers')
+        document = XDocDocument('All Servers',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
+
+        serversSection = document.createSection('All Servers')
+        serversTable = serversSection.createTable(['Name', 'Status', 'Notes',
+                                                   'Results', 'Start (Local)',
+                                                   'Start (UTC)', 'End (UTC)',
+                                                   'Offset (from UTC)'])
+
+        sortedServerList = createOrderedList(self.workspace.getServers())
+
+        scount = 0
         for server in sortedServerList:
-            
-            scount+=1
-                    
-            serverRow=serversTable.createRow()
+
+            scount += 1
+
+            serverRow = serversTable.createRow()
             serverRow.createComment(server.getName())
-                       
-            self.insertLink( server, self.workspace, serverRow.createData())
-                
-            if server.isUp():   
+
+            self.insertLink(server, self.workspace, serverRow.createData())
+
+            if server.isUp():
                 serverRow.createData('Up')
             else:
-                serverRow.createData().createStrong('Down')                     
-                                                
+                serverRow.createData().createStrong('Down')
+
             if server.hasNote():
                 serverRow.createData(server.getNote())
             else:
                 serverRow.createData('')
-            
+
             if server.hasResultsUrl():
-                serverRow.createData().createFork(	\
-                            server.getResultsUrl(),	\
-                            'Results')
+                serverRow.createData().createFork(server.getResultsUrl(),
+                                                  'Results')
             else:
                 serverRow.createData('Not Available')
-                
+
             if server.hasResults():
                 serverRow.createData(server.getResults().getStart().getLocal())
                 serverRow.createData(server.getResults().getEnd().getLocal())
@@ -688,1716 +734,1913 @@
                 serverRow.createData('N/A')
                 serverRow.createData('N/A')
                 serverRow.createData('N/A')
-        
-                        
-        if not scount: serversTable.createLine('None')
-        
+
+
+        if not scount:
+            serversTable.createLine('None')
+
         document.serialize()
-       
-    def documentTrackers(self): 
+
+    def documentTrackers(self):
         #
         # ----------------------------------------------------------------------
         #
         # Trackers.xml
         #
-        spec=self.resolver.getFileSpec(self.workspace, 'trackers')
-        document=XDocDocument( 'All Trackers',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-                
-        trackersSection=document.createSection('All Trackers')
-        trackersTable=trackersSection.createTable(['Name'])
-        
-        sortedTrackerList=createOrderedList(self.workspace.getTrackers())
-        
-        scount=0
+        spec = self.resolver.getFileSpec(self.workspace, 'trackers')
+        document = XDocDocument('All Trackers',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
+
+        trackersSection = document.createSection('All Trackers')
+        trackersTable = trackersSection.createTable(['Name'])
+
+        sortedTrackerList = createOrderedList(self.workspace.getTrackers())
+
+        scount = 0
         for tracker in sortedTrackerList:
-            
-            scount+=1
-                    
-            trackerRow=trackersTable.createRow()
+
+            scount += 1
+
+            trackerRow = trackersTable.createRow()
             trackerRow.createComment(tracker.getName())
-                       
-            self.insertLink( tracker, self.workspace, trackerRow.createData())
-            
-        if not scount: trackersTable.createLine('None')
-        
+
+            self.insertLink(tracker, self.workspace, trackerRow.createData())
+
+        if not scount:
+            trackersTable.createLine('None')
+
         document.serialize()
-       
-    def documentBuildLog(self,realTime=False): 
+
+    def documentBuildLog(self, realTime = False):
         #
         # buildLog.xml -- Modules/Projects in build order
         #
-        spec=self.resolver.getFileSpec(self.workspace, 'buildLog')
-        document=XDocDocument('Gump Build Log',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-                
-        if realTime: 
-        
+        spec = self.resolver.getFileSpec(self.workspace, 'buildLog')
+        document = XDocDocument('Gump Build Log',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
+
+        if realTime:
+
             # Work done...
             modules = len(self.gumpSet.getCompletedModules())
             projects = len(self.gumpSet.getCompletedProjects())
-        
-            document.createWarning("""This Gump run is currently in progress.
+
+            document.createWarning(
+                """This Gump run is currently in progress.
             It started at %s. As of this moment (%s), %s modules have been updated, and %s projects built.""" \
-                % (self.run.getStart().getLocal(), time.strftime('%H:%M:%S'), modules, projects ))
-                
-            #document.createNote("""Only projects with significant information 
-            #(e.g a recent change of state, a failure, etc.) are listed at runtime.""")
-          	
+                    % (self.run.getStart().getLocal(),
+                       time.strftime('%H:%M:%S'), modules, projects ))
+
+#            document.createNote(
+#                """Only projects with significant information
+#            (e.g a recent change of state, a failure, etc.) are listed at runtime.""")
+
         else:
-            document.createNote("""This Gump run is complete. 
-            It started at %s and ended at %s.""" 
-                % ( self.run.getStart().getLocal(),
+            document.createNote("""This Gump run is complete.
+            It started at %s and ended at %s."""
+                % (self.run.getStart().getLocal(),
                     self.run.getEnd().getLocal()))
-                    
+
         if not self.gumpSet.isFull():
-                self.documentPartial(document)
-             
-        if not realTime: 
-            self.documentSummary(document, self.workspace.getProjectSummary())                
-        
-        if not realTime: 
+            self.documentPartial(document)
+
+        if not realTime:
+            self.documentSummary(document, self.workspace.getProjectSummary())
+
+        if not realTime:
             #
             # Modules...
-            #        
-            modulesSection=document.createSection('Modules (in update order)')
-            modulesTable=modulesSection.createTable(['Index','Updated','Name','State','Duration\nin state','Last Modified','Notes'])
-            mcount=0
-            for module in self.gumpSet.getCompletedModules():        
-            
-                mcount+=1
-    
-                moduleRow=modulesTable.createRow()            
-                moduleRow.createComment(module.getName())  
-            
-                self.setStyleFromState(moduleRow,module.getStatePair())
-                
-                moduleRow.createData(module.getPositionIndex())    
-            
+            #
+            modulesSection = document.createSection('Modules (in update order)')
+            modulesTable = modulesSection.createTable(['Index', 'Updated',
+                                                       'Name', 'State',
+                                                       'Duration\nin state',
+                                                       'Last Modified',
+                                                       'Notes'])
+            mcount = 0
+            for module in self.gumpSet.getCompletedModules():
+
+                mcount += 1
+
+                moduleRow = modulesTable.createRow()
+                moduleRow.createComment(module.getName())
+
+                self.setStyleFromState(moduleRow, module.getStatePair())
+
+                moduleRow.createData(module.getPositionIndex())
+
                 if module.hasStart():
-                    startData=moduleRow.createData(module.getStart().getLocal())          
-                else:                    
-                    startData=moduleRow.createData('-')       
-                    
-                self.setStyleFromState(startData,module.getStatePair())
-                        
-                self.insertLink(module,self.workspace,moduleRow.createData())   
-                self.insertStateIcon(module,self.workspace,moduleRow.createData())      
-                moduleRow.createData(module.getStats().sequenceInState)    
-                moduleRow.createData(	\
-                    getGeneralSinceDescription(	\
+                    startData = moduleRow.createData(module.getStart()\
+                                                         .getLocal())
+                else:
+                    startData = moduleRow.createData('-')
+
+                self.setStyleFromState(startData, module.getStatePair())
+
+                self.insertLink(module, self.workspace, moduleRow.createData())
+                self.insertStateIcon(module, self.workspace,
+                                     moduleRow.createData())
+                moduleRow.createData(module.getStats().sequenceInState)
+                moduleRow.createData(
+                    getGeneralSinceDescription(
                         module.getStats().getLastModified()))
-                    
-                notes=''
+
+                notes = ''
                 if module.isVerbose():
-                    if notes: notes += ' '
+                    if notes:
+                        notes += ' '
                     notes += 'Verbose'
                 if module.isDebug():
-                    if notes: notes += ' '
-                    notes += 'Debug'            
-                moduleRow.createData(notes) 
-                
-            if not mcount: modulesTable.createLine('None')
-        
+                    if notes:
+                        notes += ' '
+                    notes += 'Debug'
+                moduleRow.createData(notes)
+
+            if not mcount:
+                modulesTable.createLine('None')
+
         #
         # Projects...
         #
-        projectsSection=document.createSection('Projects (in build order)')
-        projectsTable=projectsSection.createTable(['Index','Time','Name','State','Duration\nin state','Last Modified','Notes'])
-        pcount=0
+        projectsSection = document.createSection('Projects (in build order)')
+        projectsTable = projectsSection.createTable(['Index', 'Time', 'Name',
+                                                     'State',
+                                                     'Duration\nin state',
+                                                     'Last Modified', 'Notes'])
+        pcount = 0
         for project in self.gumpSet.getCompletedProjects():
-                        
+
             # Hack for bad data.
-            if not project.inModule(): continue
-                       
+            if not project.inModule():
+                continue
+
             #if realTime and \
-            #    (project.getState()==STATE_FAILED or \
-            #        ((project.getState()<>STATE_PREREQ_FAILED) and \
-            #         (project.getStats().sequenceInState < INSIGNIFICANT_DURATION))):
+            #        (project.getState()==STATE_FAILED or \
+            #             ((project.getState()<>STATE_PREREQ_FAILED) and \
+            #                  (project.getStats().sequenceInState \
+            #                       < INSIGNIFICANT_DURATION))):
             #    continue
-                
-            pcount+=1
-    
-            projectRow=projectsTable.createRow()            
-            projectRow.createComment(project.getName())  
-            
-            self.setStyleFromState(projectRow,project.getStatePair())
-            
-            projectRow.createData(project.getPositionIndex())    
-            
+
+            pcount += 1
+
+            projectRow = projectsTable.createRow()
+            projectRow.createComment(project.getName())
+
+            self.setStyleFromState(projectRow, project.getStatePair())
+
+            projectRow.createData(project.getPositionIndex())
+
             if project.hasStart():
-                projectRow.createData(project.getStart().getLocal())  
+                projectRow.createData(project.getStart().getLocal())
             else:
-                projectRow.createData('-')  
-                      
-            self.insertLink(project,self.workspace,projectRow.createData())   
-            self.insertStateIcon(project,self.workspace,projectRow.createData())      
-            projectRow.createData(project.getStats().sequenceInState)    
-            projectRow.createData(	\
-                getGeneralSinceDescription(	\
+                projectRow.createData('-')
+
+            self.insertLink(project, self.workspace, projectRow.createData())
+            self.insertStateIcon(project, self.workspace,
+                                 projectRow.createData())
+            projectRow.createData(project.getStats().sequenceInState)
+            projectRow.createData(getGeneralSinceDescription(
                     project.getModule().getStats().getLastModified()))
-                    
-            notes=''
+
+            notes = ''
             if project.isVerbose():
-                if notes: notes += ' '
+                if notes:
+                    notes += ' '
                 notes += 'Verbose'
             if project.isDebug():
-                if notes: notes += ' '
-                notes += 'Debug'            
-            projectRow.createData(notes) 
-                
-        if not pcount: projectsTable.createLine('None')
-        
-        document.serialize()
-        document=None
-      
-    def documentNotesLog(self): 
+                if notes:
+                    notes += ' '
+                notes += 'Debug'
+            projectRow.createData(notes)
+
+        if not pcount:
+            projectsTable.createLine('None')
+
+        document.serialize()
+        document = None
+
+    def documentNotesLog(self):
         #
         # ----------------------------------------------------------------------
         #
         # notesLog.xml -- Notes log
         #
-        spec=self.resolver.getFileSpec(self.workspace, 'notesLog')
-        document=XDocDocument('Annotations',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-                    
-        notesSection=document.createSection('Negative Annotations')
+        spec = self.resolver.getFileSpec(self.workspace, 'notesLog')
+        document = XDocDocument('Annotations',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
+
+        notesSection = document.createSection('Negative Annotations')
         notesSection.createParagraph(
             """This page displays entities with errors and/or warning annotations.""")
-            
-        ncount=0
-        for module in self.gumpSet.getCompletedModules():                
-                                
-            moduleSection=None
- 
-            if module.containsNasties():              
-                moduleSection=document.createSection('Module : ' + module.getName())                
+
+        ncount = 0
+        for module in self.gumpSet.getCompletedModules():
+
+            moduleSection = None
+
+            if module.containsNasties():
+                moduleSection = document.createSection('Module : ' \
+                                                           + module.getName())
                 # Link to the module
-                self.insertLink(module,self.workspace,moduleSection.createParagraph()) 
-            
+                self.insertLink(module, self.workspace,
+                                moduleSection.createParagraph())
+
                 # Display the module annotations
-                self.documentAnnotations(moduleSection,module,1)     
-                
+                self.documentAnnotations(moduleSection, module, 1)
+
             for project in module.getProjects():
-                if not self.gumpSet.inProjectSequence(project): continue               
-                if not project.containsNasties(): continue
-            
-                if not moduleSection:				
-                    moduleSection=document.createSection('Module : ' + module.getName())
+                if not self.gumpSet.inProjectSequence(project):
+                    continue
+                if not project.containsNasties():
+                    continue
+
+                if not moduleSection:
+                    moduleSection = document.createSection('Module : ' + \
+                                                               module.getName())
+
+                projectSection = moduleSection.createSection('Project : ' + \
+                                                                 project\
+                                                                 .getName())
 
-                projectSection=moduleSection.createSection('Project : ' + project.getName())
-        
                 # Link to the project
-                self.insertLink(project,self.workspace,projectSection.createParagraph())    
-            
+                self.insertLink(project, self.workspace,
+                                projectSection.createParagraph())
+
                 # Display the annotations
-                self.documentAnnotations(projectSection,project,1)     
-        
-                ncount+=1
-                
-        if not ncount: notesSection.createParagraph('None.')
-        
-        document.serialize()
-           
-    def documentDiffsLog(self): 
-        
+                self.documentAnnotations(projectSection, project, 1)
+
+                ncount += 1
+
+        if not ncount:
+            notesSection.createParagraph('None.')
+
+        document.serialize()
+
+    def documentDiffsLog(self):
+
         #
         # ----------------------------------------------------------------------
         #
         # diffsLog.xml -- Server Differences log
         #
-        spec=self.resolver.getFileSpec(self.workspace, 'diffsLog')
-        document=XDocDocument('Server Differences',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-                    
-        diffsSection=document.createSection('Server Differences')
-        diffsSection.createParagraph(
+        spec = self.resolver.getFileSpec(self.workspace, 'diffsLog')
+        document = XDocDocument('Server Differences',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
+
+        diffsSection = document.createSection('Server Differences')
+        diffsSection.createParagraph(\
             """This page displays entities with different states on different servers.""")
-            
-        dcount=0
-        for module in self.gumpSet.getCompletedModules():              
-                                
-            moduleSection=None
+
+        dcount = 0
+        for module in self.gumpSet.getCompletedModules():
+
+            moduleSection = None
             if module.hasServerResults() \
-                and module.getServerResults().hasDifferences()	\
+                and module.getServerResults().hasDifferences() \
                 and module.getServerResults().containsFailure() :
-                moduleSection=document.createSection('Module : ' + module.getName())                
+                moduleSection = document.createSection('Module : ' + \
+                                                           module.getName())
                 # Link to the module
-                self.insertLink(module,self.workspace,moduleSection.createParagraph()) 
-            
+                self.insertLink(module, self.workspace,
+                                moduleSection.createParagraph())
+
                 # Display the module server links
-                self.documentServerLinks(moduleSection,module,getDepthForObject(self.workspace))   
-                
+                self.documentServerLinks(moduleSection, module,
+                                         getDepthForObject(self.workspace))
+
             for project in module.getProjects():
-                if not self.gumpSet.inProjectSequence(project): continue         
-                if not project.hasServerResults(): continue
-                if not project.getServerResults().hasDifferences(): continue
-                if not project.getServerResults().containsFailure(): continue
-            
-                if not moduleSection:				
-                    moduleSection=document.createSection('Module : ' + module.getName())
+                if not self.gumpSet.inProjectSequence(project) \
+                        or not project.hasServerResults() \
+                        or not project.getServerResults().hasDifferences() \
+                        or not project.getServerResults().containsFailure():
+                    continue
+
+                if not moduleSection:
+                    moduleSection = document.createSection('Module : ' + \
+                                                               module.getName())
+
+                projectSection = moduleSection.createSection('Project : ' + \
+                                                                 project\
+                                                                 .getName())
 
-                projectSection=moduleSection.createSection('Project : ' + project.getName())
-        
                 # Link to the project
-                self.insertLink(project,self.workspace,projectSection.createParagraph())    
-            
+                self.insertLink(project, self.workspace,
+                                projectSection.createParagraph())
+
                 # Display the project server links
-                self.documentServerLinks(projectSection,project,getDepthForObject(self.workspace))      
-        
-                dcount+=1
-                
-        if not dcount: diffsSection.createParagraph('None.')
-        
-        document.serialize()
-           
-    def documentProjects(self): 
-    
-        sortedProjectList=createOrderedList(self.gumpSet.getProjectSequence())
-       
+                self.documentServerLinks(projectSection, project,
+                                         getDepthForObject(self.workspace))
+
+                dcount += 1
+
+        if not dcount:
+            diffsSection.createParagraph('None.')
+
+        document.serialize()
+
+    def documentProjects(self):
+
+        sortedProjectList = createOrderedList(self.gumpSet.getProjectSequence())
+
         #
         # ----------------------------------------------------------------------
         #
         # project_todos.xml -- Projects w/ issues in build order
         #
-        spec=self.resolver.getFileSpec(self.workspace, 'project_todos')
-        document=XDocDocument('Projects with issues',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
+        spec = self.resolver.getFileSpec(self.workspace, 'project_todos')
+        document = XDocDocument('Projects with issues',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
         self.documentSummary(document, self.workspace.getProjectSummary())
-        
-        totalAffected=0
-        
-        projectsSection=document.createSection('Projects with issues...')
-        projectsSection.createParagraph("""These are the project that need 'fixing'.
-This page helps Gumpmeisters (and others) locate the main areas to focus attention.""")        
-        projectsTable=projectsSection.createTable(['Name',
-                        'Dependees','Affected',
-                        'Project State','Duration\nin state'])
-        pcount=0
-        
-        depOrder=createOrderedList(sortedProjectList,compareProjectsByFullDependeeCount)
-  
+
+        totalAffected = 0
+
+        projectsSection = document.createSection('Projects with issues...')
+        projectsSection.createParagraph(\
+            """These are the project that need 'fixing'.
+This page helps Gumpmeisters (and others) locate the main areas to focus attention.""")
+        projectsTable = projectsSection.createTable(['Name',
+                                                     'Dependees', 'Affected',
+                                                     'Project State',
+                                                     'Duration\nin state'])
+        pcount = 0
+
+        depOrder = createOrderedList(sortedProjectList,
+                                     compareProjectsByFullDependeeCount)
+
         for project in depOrder:
             # Hack for bad data
-            if not project.inModule(): continue
-                
-            if not self.gumpSet.inProjectSequence(project): continue       
-            
-            if not project.getState()==STATE_FAILED:
-                continue
-                
-            pcount+=1
-        
-            #
+            if not project.inModule():
+                continue
+
+            if not self.gumpSet.inProjectSequence(project):
+                continue
+
+            if not project.getState() == STATE_FAILED:
+                continue
+
+            pcount += 1
+
+            #
             # Determine the number of projects this module (or its projects)
             # cause not to be run.
             #
-            affected=project.countAffectedProjects()
-            
+            affected = project.countAffectedProjects()
+
             totalAffected += affected
-            
-                    
-            projectRow=projectsTable.createRow()
+
+
+            projectRow = projectsTable.createRow()
             projectRow.createComment(project.getName())
-                                    
-            self.insertLink(project,self.workspace,projectRow.createData())   
-                                    
-            projectRow.createData( project.getFullDependeeCount())
+
+            self.insertLink(project, self.workspace, projectRow.createData())
+
+            projectRow.createData(project.getFullDependeeCount())
             projectRow.createData(affected)
-            
-            self.insertStateIcon(project,self.workspace,projectRow.createData())
-            
+
+            self.insertStateIcon(project, self.workspace,
+                                 projectRow.createData())
+
             # How long been like this
-            seq=stats=project.getStats().sequenceInState 
+            seq = project.getStats().sequenceInState
             projectRow.createData(seq)
-                
-        if not pcount: 
-            projectsTable.createLine('None')    
+
+        if not pcount:
+            projectsTable.createLine('None')
         else:
             projectsSection.createParagraph(
                     'Total Affected Projects: ' + str(totalAffected))
-                    
+
         document.serialize()
-                 
+
         #
         # ----------------------------------------------------------------------
         #
         # project_fixes.xml -- Projects w/ fixes in build order
         #
-        spec=self.resolver.getFileSpec(self.workspace, 'project_fixes')
-        document=XDocDocument('Project Fixes',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
+        spec = self.resolver.getFileSpec(self.workspace, 'project_fixes')
+        document = XDocDocument('Project Fixes',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
         self.documentSummary(document, self.workspace.getProjectSummary())
-        
-        projectsSection=document.createSection('Projects recently fixed...')
-        projectsSection.createParagraph("""These are the projects that were 'fixed' (state changed to success from failed) within %s runs.
+
+        projectsSection = document.createSection('Projects recently fixed...')
+        projectsSection.createParagraph(\
+            """These are the projects that were 'fixed' (state changed to success from failed) within %s runs.
 This page helps Gumpmeisters (and others) observe community progress.
-        """ % INSIGNIFICANT_DURATION)      
-        
-        projectsTable=projectsSection.createTable(['Name',	\
-                    'Dependees','Project State','Duration\nin state'])
-        pcount=0
+        """ % INSIGNIFICANT_DURATION)
+
+        projectsTable = projectsSection.createTable(['Name', 'Dependees',
+                                                     'Project State',
+                                                     'Duration\nin state'])
+        pcount = 0
         for project in sortedProjectList:
             # Hack for bad data
-            if not project.inModule(): continue    
+            if not project.inModule():
+                continue
             # Filter
-            if not self.gumpSet.inProjectSequence(project): continue       
-            
-            if not project.getState()==STATE_SUCCESS or \
-                not project.getStats().previousState==STATE_FAILED or \
+            if not self.gumpSet.inProjectSequence(project):
+                continue
+
+            if not project.getState() == STATE_SUCCESS or \
+                not project.getStats().previousState == STATE_FAILED or \
                 not project.getStats().sequenceInState < INSIGNIFICANT_DURATION:
                 continue
-                
-            pcount+=1
-            
-            projectRow=projectsTable.createRow()
+
+            pcount += 1
+
+            projectRow = projectsTable.createRow()
             projectRow.createComment(project.getName())
-                                    
-            self.insertLink(project,self.workspace,projectRow.createData())   
-            
-            projectRow.createData( project.getFullDependeeCount())
-            
-            self.insertStateIcon(project,self.workspace,projectRow.createData())
-            
+
+            self.insertLink(project, self.workspace, projectRow.createData())
+
+            projectRow.createData(project.getFullDependeeCount())
+
+            self.insertStateIcon(project, self.workspace,
+                                 projectRow.createData())
+
             # How long been like this
-            seq=stats=project.getStats().sequenceInState
+            seq = project.getStats().sequenceInState
             projectRow.createData(seq)
-                
-        if not pcount: 
-            projectsTable.createLine('None')   
-                    
+
+        if not pcount:
+            projectsTable.createLine('None')
+
         document.serialize()
-        
+
         #
         # ----------------------------------------------------------------------
         #
         # project_prereqs.xml -- Projects w/ prereqs in build order
         #
-        spec=self.resolver.getFileSpec(self.workspace, 'project_prereqs')
-        document=XDocDocument('Project Prerequisite Failures',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
+        spec = self.resolver.getFileSpec(self.workspace, 'project_prereqs')
+        document = XDocDocument('Project Prerequisite Failures',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
         self.documentSummary(document, self.workspace.getProjectSummary())
-        
-        projectsSection=document.createSection('Projects recently fixed...')
-        projectsSection.createParagraph("""These are the projects that depend upon others being fixed before they can be built.""")      
-        
-        projectsTable=projectsSection.createTable(['Name',    \
-                    'Depends','Not-Built Depends','Project State','Duration\nin state'])
-        pcount=0
+
+        projectsSection = document.createSection('Projects recently fixed...')
+        projectsSection.createParagraph(\
+            """These are the projects that depend upon others being fixed before they can be built.""")
+
+        projectsTable = projectsSection.createTable(['Name', 'Depends',
+                                                     'Not-Built Depends',
+                                                     'Project State',
+                                                     'Duration\nin state'])
+        pcount = 0
         for project in sortedProjectList:
             # Hack for bad data
-            if not project.inModule(): continue    
-            # Filter    
-            if not self.gumpSet.inProjectSequence(project): continue       
-            
-            if not project.getState()==STATE_PREREQ_FAILED:
-                continue
-                
-            pcount+=1
-            
-            projectRow=projectsTable.createRow()
+            if not project.inModule():
+                continue
+            # Filter
+            if not self.gumpSet.inProjectSequence(project):
+                continue
+
+            if not project.getState() == STATE_PREREQ_FAILED:
+                continue
+
+            pcount += 1
+
+            projectRow = projectsTable.createRow()
             projectRow.createComment(project.getName())
-                                    
-            self.insertLink(project,self.workspace,projectRow.createData())   
-            
+
+            self.insertLink(project, self.workspace, projectRow.createData())
+
             projectRow.createData(project.getFullDependencyCount())
-            
+
             # Count unbuilt dependencies
-            unbuilt=0
+            unbuilt = 0
             for dep in project.getFullDependencyProjectList():
                 if not dep.isSuccess():
-                    unbuilt+=1
+                    unbuilt += 1
             projectRow.createData(unbuilt)
-            
-            self.insertStateIcon(project,self.workspace,projectRow.createData())
-            
+
+            self.insertStateIcon(project, self.workspace,
+                                 projectRow.createData())
+
             # How long been like this
-            seq=stats=project.getStats().sequenceInState
+            seq = project.getStats().sequenceInState
             projectRow.createData(seq)
-                
-        if not pcount: 
-            projectsTable.createLine('None')   
-                    
-        document.serialize()
-           
-    def documentModules(self):  
-     
+
+        if not pcount:
+            projectsTable.createLine('None')
+
+        document.serialize()
+
+    def documentModules(self):
+
         #
         # ----------------------------------------------------------------------
         #
         # module_todos.xml
         #
-        spec=self.resolver.getFileSpec(self.workspace, 'module_todos')
-        document=XDocDocument('Modules with issues',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-        
-        modulesSection=document.createSection('Modules with TODOs')               
-        modulesSection.createParagraph("""These are the modules that need 'fixing', or contained projects that need fixing.
-This page helps Gumpmeisters (and others) locate the main areas to focus attention.""")        
-        modulesTable=modulesSection.createTable(['Name','Duration\nin state','Module State',	\
-                                    'Project State(s)','Elapsed'])
-        
-        mcount=0
-        for module in self.gumpSet.getCompletedModules():  
-            
+        spec = self.resolver.getFileSpec(self.workspace, 'module_todos')
+        document = XDocDocument('Modules with issues',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
+
+        modulesSection = document.createSection('Modules with TODOs')
+        modulesSection.createParagraph(\
+            """These are the modules that need 'fixing', or contained projects that need fixing.
+This page helps Gumpmeisters (and others) locate the main areas to focus attention.""")
+        modulesTable = modulesSection.createTable(['Name', 'Duration\nin state',
+                                                   'Module State',
+                                                   'Project State(s)',
+                                                   'Elapsed'])
+
+        mcount = 0
+        for module in self.gumpSet.getCompletedModules():
+
             #
             # Determine if there are todos, otherwise continue
             #
-            todos=0
+            todos = 0
             for pair in module.aggregateStates():
-                if pair.state==STATE_FAILED:
-                    todos=1                    
-            if not todos: continue    
+                if pair.state == STATE_FAILED:
+                    todos = 1
+            if not todos:
+                continue
             # Shown something...
-            mcount+=1
-            
+            mcount += 1
+
             # Determine longest sequence in this (failed) state...
             # for any of the projects
-            seq=0
+            seq = 0
             for project in module.getProjects():
-                if project.getState()==STATE_FAILED:
-                    stats=project.getStats()        
-                    if stats.sequenceInState > seq: seq = stats.sequenceInState
-    
+                if project.getState() == STATE_FAILED:
+                    stats = project.getStats()
+                    if stats.sequenceInState > seq:
+                        seq = stats.sequenceInState
+
             # Determine the number of projects this module (or its projects)
             # cause not to be run.
-            
+
             # Display
-            moduleRow=modulesTable.createRow()
-            moduleRow.createComment(module.getName())     
-            self.insertLink(module,self.workspace,moduleRow.createData())
-            
+            moduleRow = modulesTable.createRow()
+            moduleRow.createComment(module.getName())
+            self.insertLink(module, self.workspace, moduleRow.createData())
+
             moduleRow.createData(seq)
-                        
-            self.insertStateIcon(module,self.workspace,moduleRow.createData())
-            self.insertStateIcons(module,self.workspace,moduleRow.createData())
-            
-            moduleRow.createData(secsToElapsedTimeString(module.getElapsedSecs()))
-            
-        if not mcount: modulesTable.createLine('None')
-    
+
+            self.insertStateIcon(module, self.workspace, moduleRow.createData())
+            self.insertStateIcons(module, self.workspace,
+                                  moduleRow.createData())
+
+            moduleRow.createData(secsToElapsedTimeString(module\
+                                                             .getElapsedSecs()))
+
+        if not mcount:
+            modulesTable.createLine('None')
+
         document.serialize()
-        
-           
+
+
         #
         # ----------------------------------------------------------------------
         #
         # module_fixes.xml
         #
-        spec=self.resolver.getFileSpec(self.workspace, 'module_fixes')
-        document=XDocDocument('Modules with fixes',    
-                spec.getFile() ,
-                self.config,
-                spec.getRootPath())
-        
-        modulesSection=document.createSection('Modules recently fixed')           
-        modulesSection.createParagraph("""These are the modules that were 'fixed' (state changed to success), or contained projects that were fixed, within %s runs.
+        spec = self.resolver.getFileSpec(self.workspace, 'module_fixes')
+        document = XDocDocument('Modules with fixes',
+                                spec.getFile(),
+                                self.config,
+                                spec.getRootPath())
+
+        modulesSection = document.createSection('Modules recently fixed')
+        modulesSection.createParagraph(\
+            """These are the modules that were 'fixed' (state changed to success), or contained projects that were fixed, within %s runs.
 This page helps Gumpmeisters (and others) observe community progress.
-        """ % INSIGNIFICANT_DURATION)      
-             
-        modulesTable=modulesSection.createTable(['Name','Duration\nin state','Module State',	\
-                                    'Project State(s)','Elapsed'])
-        
-        mcount=0
-        for module in self.gumpSet.getCompletedModules():  
-            
+        """ % INSIGNIFICANT_DURATION)
+
+        modulesTable = modulesSection.createTable(['Name', 'Duration\nin state',
+                                                   'Module State',
+                                                   'Project State(s)',
+                                                   'Elapsed'])
+
+        mcount = 0
+        for module in self.gumpSet.getCompletedModules():
+
             #
             # Determine if there are mcount, otherwise continue
             #
-            mcount=0
+            mcount = 0
             for pair in module.aggregateStates():
                 if pair.state == STATE_SUCCESS \
-                    and module.getStats().sequenceInState < INSIGNIFICANT_DURATION:
-                    mcount=1
-                    
-            if not mcount: continue
-    
+                    and module.getStats().sequenceInState < \
+                    INSIGNIFICANT_DURATION:
+                    mcount = 1
+
+            if not mcount:
+                continue
+
             # Shown something...
-            mcount+=1
-            
+            mcount += 1
+

[... 4246 lines stripped ...]


Mime
View raw message