SortModuleTimes.TabularAlignmentClass Class Reference

Classes
class	CatchAllLines
class	FormatNotSupported
class	LineIdentifierClass
class	LineNo

Public Member Functions
def	__init__ (self, specs=[None)
def	ParseFormatSpec (self, spec)
def	SetRowFormats (self, rowSelector, specs)
def	SetDefaultFormats (self, specs)
def	AddData (self, data)
def	AddRow (self, row_data)
def	SelectFormat (self, iLine)
def	FormatTable (self)
def	ToStrings (self, separator=" ")
def	Print (self, stream=sys.stdout)

Public Attributes
	tabledata
	formats

Detailed Description

Formats list of data in a table

Definition at line 691 of file SortModuleTimes.py.

Constructor & Destructor Documentation

def SortModuleTimes.TabularAlignmentClass.__init__	(		self,
			specs = [ None
	)

Each format specification applies to one item in each row.
If no format specification is supplied for an item, the last used format
is applied. By default, that is a plain conversion to string.

Definition at line 693 of file SortModuleTimes.py.

        def __init__(self, specs = [ None, ]):
                """
                Each format specification applies to one item in each row.
                If no format specification is supplied for an item, the last used format
                is applied. By default, that is a plain conversion to string.
                """
                self.tabledata = []
                self.formats = {}
                if specs: self.SetDefaultFormats(specs)

Member Function Documentation

def SortModuleTimes.TabularAlignmentClass.AddData	(		self,
			data
	)

Definition at line 765 of file SortModuleTimes.py.

        def AddData(self, data): self.tabledata.extend(data)

def SortModuleTimes.TabularAlignmentClass.AddRow	(		self,
			row_data
	)

Definition at line 766 of file SortModuleTimes.py.

        def AddRow(self, *row_data): self.tabledata.append(row_data)

def SortModuleTimes.TabularAlignmentClass.FormatTable

(

self

)

Definition at line 783 of file SortModuleTimes.py.

        def FormatTable(self):
                # select the formats for all lines
                AllFormats \
                  = [ self.SelectFormat(iRow) for iRow in xrange(len(self.tabledata)) ]

                # format all the items
                ItemLengths = MaxItemLengthsClass()
                TableContent = []
                for iRow, rowdata in enumerate(self.tabledata):
                        RowFormats = AllFormats[iRow]
                        LineContent = []
                        LastSpec = None
                        for iItem, itemdata in enumerate(rowdata):
                                try:
                                        Spec = RowFormats[iItem]
                                        LastSpec = Spec
                                except IndexError: Spec = LastSpec

                                Formatter = Spec['format']
                                if isinstance(Formatter, basestring):
                                        ItemContent = Formatter % itemdata
                                elif callable(Formatter):
                                        ItemContent = Formatter(itemdata)
                                else:
                                        raise RuntimeError("Formatter %r (#%d) not supported."
                                        % (Formatter, iItem))
                                # if ... else
                                LineContent.append(ItemContent)
                        # for items
                        ItemLengths.add(LineContent)
                        TableContent.append(LineContent)
                # for rows

                # pad the objects
                for iRow, rowdata in enumerate(TableContent):
                        RowFormats = AllFormats[iRow]
                        Spec = AllFormats[iRow]
                        for iItem, item in enumerate(rowdata):
                                try:
                                        Spec = RowFormats[iItem]
                                        LastSpec = Spec
                                except IndexError: Spec = LastSpec

                                fieldWidth = ItemLengths[iItem]
                                alignment = Spec.get('align', 'left')
                                if alignment == 'right':
                                        alignedItem = RightString(item, fieldWidth)
                                elif alignment == 'justified':
                                        alignedItem = JustifyString(item, fieldWidth)
                                elif alignment == 'center':
                                        alignedItem = CenterString(item, fieldWidth)
                                else: # if alignment == 'left':
                                        alignedItem = LeftString(item, fieldWidth)
                                if Spec.get('truncate', True): alignedItem = alignedItem[:fieldWidth]

                                rowdata[iItem] = alignedItem
                        # for items
                # for rows
                return TableContent

def SortModuleTimes.TabularAlignmentClass.ParseFormatSpec	(		self,
			spec
	)

Definition at line 738 of file SortModuleTimes.py.

        def ParseFormatSpec(self, spec):
                SpecData = {}
                if spec is None: SpecData['format'] = str
                elif isinstance(spec, basestring): SpecData['format'] = spec
                elif isinstance(spec, dict):
                        SpecData = spec
                        SpecData.setdefault('format', str)
                else: raise TabularAlignmentClass.FormatNotSupported(spec)
                return SpecData

def SortModuleTimes.TabularAlignmentClass.Print	(		self,
			stream = sys.stdout
	)

Definition at line 847 of file SortModuleTimes.py.

        def Print(self, stream = sys.stdout):
                print "\n".join(self.ToStrings())

# class TabularAlignmentClass

def SortModuleTimes.TabularAlignmentClass.SelectFormat	(		self,
			iLine
	)

Definition at line 769 of file SortModuleTimes.py.

        def SelectFormat(self, iLine):
                rowdata = self.tabledata[iLine]
                success = None
                bestFormat = None
                for lineMatcher, format_ in self.formats.items():
                        match_success = lineMatcher(iLine, self.tabledata)
                        if match_success <= success: continue
                        bestFormat = format_
                        success = match_success
                # for
                return bestFormat

def SortModuleTimes.TabularAlignmentClass.SetDefaultFormats	(		self,
			specs
	)

Definition at line 762 of file SortModuleTimes.py.

        def SetDefaultFormats(self, specs):
                self.SetRowFormats(TabularAlignmentClass.CatchAllLines(), specs)

def SortModuleTimes.TabularAlignmentClass.SetRowFormats	(		self,
			rowSelector,
			specs
	)

Definition at line 749 of file SortModuleTimes.py.

        def SetRowFormats(self, rowSelector, specs):
                # parse the format specifications
                formats = []
                for iSpec, spec in enumerate(specs):
                        try:
                                formats.append(self.ParseFormatSpec(spec))
                        except TabularAlignmentClass.FormatNotSupported, e:
                                raise RuntimeError("Format specification %r (#%d) not supported."
                                  % (str(e), iSpec))
                # for specifications
                self.formats[rowSelector] = formats

def SortModuleTimes.TabularAlignmentClass.ToStrings	(		self,
			separator = " "
	)

Definition at line 844 of file SortModuleTimes.py.

        def ToStrings(self, separator = " "):
                return [ separator.join(RowContent) for RowContent in self.FormatTable() ]

Member Data Documentation

SortModuleTimes.TabularAlignmentClass.formats

Definition at line 700 of file SortModuleTimes.py.

SortModuleTimes.TabularAlignmentClass.tabledata

Definition at line 699 of file SortModuleTimes.py.

---

The documentation for this class was generated from the following file:

• larutils/scripts/SortModuleTimes.py