def _getRowByIndex(self, idx):
assert idx > 0, f"Wrong row index: {idx}"
rown = 0
for row in self.__sheet.getElementsByType(TableRow):
n = int(row.getAttribute('numberrowsrepeated') or 1)
if rown + n > idx:
if idx - rown == 1:
# we are in the target row, just remove the repeated attribute
# and insert a new row with repeated decreased by 1
row.removeAttribute('numberrowsrepeated')
newrow = TableRow(stylename=row.getAttribute('stylename'), numberrowsrepeated=n - 1)
self.__sheet.insertBefore(newrow, row.nextSibling)
return Row(idx, row)
# we are in a previous row, just remove the repeated, and add two new rows,
# one being the target row and another with repeated decreased by two
row.removeAttribute('numberrowsrepeated')
nextSibling = row.nextSibling
newrow = TableRow(stylename=row.getAttribute('stylename'))
self.__sheet.insertBefore(newrow, nextSibling)
if n > 2:
newnewrow = TableRow(stylename=row.getAttribute('stylename'))
if n > 3:
newnewrow.setAttribute('numberrowsrepeated', n - 2)
self.__sheet.insertBefore(newnewrow, nextSibling)
return Row(idx, newrow)
if rown + n == idx:
return Row(idx, row)
rown += n
raise ValueError(f"Error retrieving row {idx}")
def addTable(self,tabledata,headers,formater=None):
if formater and len(formater)!=len(tabledata):
raise ValueError
if formater is None:
formater = [[""]*len(tabledata[0])]*len(tabledata)
table = Table()
columns = len(headers)
table.addElement(TableColumn(numbercolumnsrepeated=columns))
tr = TableRow()
table.addElement(tr)
for header in headers:
tc = TableCell(stylename="Table")
tr.addElement(tc)
p = P(stylename=self.tableheaders,text=header)
tc.addElement(p)
for line,formats in zip(tabledata,formater):
tr = TableRow()
table.addElement(tr)
for column,cformat in zip(line,formats):
if cformat == "centerred":
cellformat = self.tablecontentscenter
elif cformat == "center":
cellformat = self.tablecontentscenterred
else:
cellformat = self.tablecontents
tc = TableCell(stylename="Table")
tr.addElement(tc)
p = P(stylename=cellformat,text=column)
tc.addElement(p)
self.textdoc.text.addElement(table)
def generate_ods(data):
"""
Generate a ODS file.
:param data: list-like of dict with the data.
:return:
"""
doc = OpenDocumentSpreadsheet()
table = Table()
tr = TableRow()
colautowidth = Style(name="co1", family="table-column")
colautowidth.addElement(TableColumnProperties(useoptimalcolumnwidth=True))
doc.automaticstyles.addElement(colautowidth)
for column in data[0].keys():
table.addElement(TableColumn(stylename=colautowidth))
tc = TableCell(valuetype="string", value=column)
tc.addElement(P(text=column))
tr.addElement(tc)
table.addElement(tr)
for row in data:
tr = TableRow()
for column in row.keys():
tc = TableCell(valuetype="string", value=row[column])
tc.addElement(P(text=row[column]))
tr.addElement(tc)
table.addElement(tr)
file = os.path.join(
tempfile.gettempdir(),
'SIGE' + datetime.now().strftime('%Y%m%d%H%M%S%f') + '.ods')
doc.spreadsheet.addElement(table)
print(doc.automaticstyles.childNodes[0].attributes)
doc.save(file)
return file
def add_title(self, title, width):
row = TableRow()
cell = TableCell(stylename="title")
cell.setAttrNS(TABLENS, "number-columns-spanned", width)
cell.addElement(P(text=title))
row.addElement(cell)
self.sheet.addElement(row)
def calc(title, xlabel, ylabel, xdata, ydata):
from odf.opendocument import OpenDocumentSpreadsheet
from odf.text import P
from odf.table import Table, TableColumn, TableRow, TableCell
outfile = NamedTemporaryFile(mode='wb',
suffix='.ods',
prefix='eyesCalc_',
delete=False)
doc = OpenDocumentSpreadsheet()
table = Table(
name="ExpEYES {0}".format(time.strftime("%Y-%m-%d %Hh%Mm%Ss")))
doc.spreadsheet.addElement(table)
## add rows into the table
for i in range(len(xdata)):
tr = TableRow()
table.addElement(tr)
if len(ydata.shape) == 1:
# single y data
tr.addElement(TableCell(valuetype="float", value=str(xdata[i])))
tr.addElement(TableCell(valuetype="float", value=str(ydata[i])))
else:
# multiple y data
tr.addElement(TableCell(valuetype="float", value=str(xdata[i])))
for j in range(ydata.shape[0]):
tr.addElement(
TableCell(valuetype="float", value=str(ydata[j][i])))
doc.save(outfile)
outfile.close()
call("(localc {}&)".format(outfile.name), shell=True)
return [outfile]
def addTableOnBookmark(self, bookmarkName, tableData, enumerated=False):
'''Вставка таблицы перед закладкой
'''
table_columns = 3 if enumerated else 2
#Создание и заполнение таблицы
table = Table()
table.addElement(TableColumn(numbercolumnsrepeated=table_columns))
for index, row in enumerate(tableData):
tr = TableRow()
table.addElement(tr)
if enumerated:
tc = TableCell()
tr.addElement(tc)
tc.addElement(P(text=str(index + 1)))
for item in row:
tc = TableCell()
tr.addElement(tc)
tc.addElement(
P(text=str(item) if type(item) != QVariant else ''))
bookmarks = self.doc.getElementsByType(BookmarkStart)
#Вставка таблицы в content.xml
for bookmark in bookmarks:
if bookmark.getAttribute("name") == bookmarkName:
bookmark.parentNode.parentNode.insertBefore(
table, bookmark.parentNode)
bookmark.parentNode.parentNode.insertBefore(
P(text=""), bookmark.parentNode)
self.doc.save(root + r"/releasedDocs/Документ", True)
def save_table(filename, form, datatable):
cols = datatable.columnCount()
rows = datatable.rowCount()
if form == "Text Files (*.odt)":
doc = OpenDocumentSpreadsheet()
table = Table()
for row in range(rows):
tr = TableRow()
for col in range(cols):
tc = TableCell(valuetype='string')
data = datatable.model().index(row, col).data()
if data is None:
data = ""
tc.addElement(P(text=data))
tr.addElement(tc)
table.addElement(tr)
doc.spreadsheet.addElement(table)
doc.save(filename, True)
elif form == "Text Files (*.docx)":
doc = docx.Document()
table = doc.add_table(rows=rows, cols=cols)
table.style = 'Table Grid'
for row in range(rows):
for col in range(cols):
cell = table.cell(row, col)
data = datatable.model().index(row, col).data()
if data is None:
data = ""
cell.text = data
doc.save(filename)
def test_percentage(self):
""" Test that an automatic style can refer to a PercentageStyle as a datastylename """
doc = OpenDocumentSpreadsheet()
nonze = PercentageStyle(name='N11')
nonze.addElement(Number(decimalplaces='2', minintegerdigits='1'))
nonze.addElement(Text(text='%'))
doc.automaticstyles.addElement(nonze)
pourcent = Style(name='pourcent',
family='table-cell',
datastylename='N11')
pourcent.addElement(ParagraphProperties(textalign='center'))
pourcent.addElement(
TextProperties(attributes={
'fontsize': "10pt",
'fontweight': "bold",
'color': "#000000"
}))
doc.automaticstyles.addElement(pourcent)
table = Table(name='sheet1')
tr = TableRow()
tc = TableCell(formula='=AVERAGE(C4:CB62)/2',
stylename='pourcent',
valuetype='percentage')
tr.addElement(tc)
table.addElement(tr)
doc.spreadsheet.addElement(table)
doc.save(u"TEST.ods")
self.saved = True
d = load(u"TEST.ods")
result = d.contentxml() # contentxml is supposed to yeld a bytes
self.assertNotEqual(-1, result.find(b'''<number:percentage-style'''))
self.assertNotEqual(-1,
result.find(b'''style:data-style-name="N11"'''))
self.assertNotEqual(-1, result.find(b'''style:name="pourcent"'''))
def get_odf_spreadsheet(sheets):
"""Creates a spreadsheet from a dictionary sheets of
dictionary entries sheetname -> nested list of rows"""
doc = OpenDocumentSpreadsheet()
spreadsheet = doc.spreadsheet
for sheet_name, list_rows in sheets.iteritems():
sheet = Table()
spreadsheet.addElement(sheet)
sheet.setAttribute("name", sheet_name)
for list_row in list_rows:
table_row = TableRow()
for cell_content in list_row:
vtype = valuetype(cell_content)
if vtype == "boolean":
cell_content = ("True" if cell_content else "False")
vtype = "string"
elif vtype == "string":
cell_content = unicodedata.normalize(
'NFKD',
unicode(cell_content)).encode('ascii', 'ignore')
table_cell = TableCell(valuetype=vtype, value=cell_content)
if vtype == "string":
s = str(cell_content)
table_cell.addElement(P(text=s))
table_row.addElement(table_cell)
sheet.addElement(table_row)
st = StringIO()
doc.write(st)
return st.getvalue()
def write_row(self, array):
"""
write a row into the file
"""
row = TableRow()
self._native_sheet.addElement(row)
for cell in array:
self.write_cell(row, cell)
def row(rec):
tr = TableRow()
table.addElement(tr)
for r in rec:
tc = TableCell()
tr.addElement(tc)
p = P(stylename=tablecontents, text=r)
tc.addElement(p)
def _write_cells(
self,
cells: list[ExcelCell],
sheet_name: str | None = None,
startrow: int = 0,
startcol: int = 0,
freeze_panes: tuple[int, int] | None = None,
) -> None:
"""
Write the frame cells using odf
"""
from odf.table import (
Table,
TableCell,
TableRow,
)
from odf.text import P
sheet_name = self._get_sheet_name(sheet_name)
assert sheet_name is not None
if sheet_name in self.sheets:
wks = self.sheets[sheet_name]
else:
wks = Table(name=sheet_name)
self.book.spreadsheet.addElement(wks)
if validate_freeze_panes(freeze_panes):
freeze_panes = cast(Tuple[int, int], freeze_panes)
self._create_freeze_panes(sheet_name, freeze_panes)
for _ in range(startrow):
wks.addElement(TableRow())
rows: DefaultDict = defaultdict(TableRow)
col_count: DefaultDict = defaultdict(int)
for cell in sorted(cells, key=lambda cell: (cell.row, cell.col)):
# only add empty cells if the row is still empty
if not col_count[cell.row]:
for _ in range(startcol):
rows[cell.row].addElement(TableCell())
# fill with empty cells if needed
for _ in range(cell.col - col_count[cell.row]):
rows[cell.row].addElement(TableCell())
col_count[cell.row] += 1
pvalue, tc = self._make_table_cell(cell)
rows[cell.row].addElement(tc)
col_count[cell.row] += 1
p = P(text=pvalue)
tc.addElement(p)
# add all rows to the sheet
if len(rows) > 0:
for row_nr in range(max(rows.keys()) + 1):
wks.addElement(rows[row_nr])
def writerow(self, items):
self.exrow += 1
#pass
# If there is and image in the row, make the row high
textrow = True
for item in items:
if isinstance(item, np.ndarray):
textrow = False
break
if textrow:
tr = TableRow(stylename=self.itemRowStyle1)
else:
tr = TableRow(stylename=self.itemRowStyle3)
cells = "ABCDEFGHIJKLM"
for n in range(len(items)):
if isinstance(items[n], (int, np.int64)):
tc = TableCell(valuetype="float", value=str(items[n]), stylename="cellStyle1")
p = P(text=items[n])
elif isinstance(items[n], float):
tc = TableCell(valuetype="float", value=str("%4.1f"%items[n]), stylename="cellStyle1")
p = P(text=items[n])
elif isinstance(items[n], np.ndarray):
tc = TableCell(stylename="cellStyle1")
fname = tempfile.mktemp(".jpg")
sf=0.08
im = items[n]
imageio.imwrite(fname, items[n])
f = draw.Frame(endcelladdress="import.%s%d"%(cells[n],self.exrow),endx="%dmm"%int(sf*im.shape[1]), endy="%dmm"%int(sf*im.shape[0]))
tc.addElement(f)
href=self.doc.addPicture(fname)
i = draw.Image(href=href, type="simple", show="embed", actuate="onLoad")
f.addElement(i)
p = P(text="")
i.addElement(p)
else:
tc = TableCell(stylename="cellStyle1") #empty cell
p = P(text=items[n])
tc.addElement(p)
tr.addElement(tc)
self.table.addElement(tr)
return
def writer(data, **kwargs):
"""
Liberally adapted from odfpy's csv2ods script.
"""
def handle_formula(f):
return TableCell(valuetype="float", formula="{}".format(f))
textdoc = OpenDocumentSpreadsheet(**kwargs)
# Create a style for the table content. One we can modify
# later in the word processor.
tablecontents = Style(name="Table Contents", family="paragraph")
tablecontents.addElement(
ParagraphProperties(numberlines="false", linenumber="0"))
tablecontents.addElement(TextProperties(fontweight="bold"))
textdoc.styles.addElement(tablecontents)
# Start the table
table = Table(name=u'Sheet 1')
fltExp = re.compile('^\s*[-+]?\d+(\.\d+)?\s*$')
for row in data:
tr = TableRow()
table.addElement(tr)
for val in row:
if isinstance(val, spreadsheet.Formula):
tc = handle_formula(val)
else:
valuetype = 'string'
if not isinstance(val, unicode):
if isinstance(val, str):
text_value = "{}".format(val, PWENC, 'replace')
else:
text_value = "{}".format(val)
else:
text_value = val
if isinstance(val, (float, int, long)) or (isinstance(
val, str) and fltExp.match(text_value)):
valuetype = 'float'
if valuetype == 'float':
tc = TableCell(valuetype="float", value=text_value.strip())
else:
tc = TableCell(valuetype=valuetype)
if val is not None:
p = P(stylename=tablecontents, text=text_value)
tc.addElement(p)
tr.addElement(tc)
textdoc.spreadsheet.addElement(table)
result = StringIO()
textdoc.write(result)
return result.getvalue()
def convert_FFPtable_day(path):
name = "FFPtable.day"
table = Table(name=name)
with open(path) as fin:
line = fin.readline().split()[2:]
row = TableRow()
for year in line:
table.addElement(TableColumn())
cell = TableCell(valuetype="float", value=year)
row.addElement(cell)
table.addElement(row)
for line in fin.readlines():
line = line.split()[2:]
row = TableRow()
for item in line:
cell = TableCell(valuetype="float", value=item)
row.addElement(cell)
table.addElement(row)
return table
def _toODSTable(v_table):
# generate an ods file to download
# input: Object VoteTable
# output: Object ods.table
table= Table(name=v_table.title)
row_head = v_table.row_head
col_head = v_table.col_head
table_body = v_table.table_body
# Render column head if it is a 2D table
if v_table.is2D():
table.name = '2D'
tr= TableRow()
table.addElement(tr)
td= TableCell()
td.addElement(P(text='Head'))
tr.addElement(td)
for headcell in v_table.col_head:
td= TableCell()
td.addElement(P(text=headcell.content))
tr.addElement(td)
for cursorRow in v_table.table_with_row:
tr= TableRow()
table.addElement(tr)
td= TableCell()
td.addElement(P(text=cursorRow['row_head'].content))
tr.addElement(td)
for val in cursorRow['row_body']:
td= TableCell()
td.addElement(P(text=val))
tr.addElement(td)
#myFile= tempfile.TemporaryFile('/tmp/')
#doc.save('/tmp/test', True)
return table
def _create_odf(self):
doc = OpenDocumentSpreadsheet()
table = Table(name="Table1")
for row in self.df.values:
tr = TableRow()
for val in row:
tc = TableCell(valuetype="string")
tc.addElement(P(text=val))
tr.addElement(tc)
table.addElement(tr)
doc.spreadsheet.addElement(table)
doc.save(self.fname_odf)
def write_table(self, name):
table = Table(name=name)
tr = TableRow()
for header in self.sheet_data[name]["headers"]:
tc = TableCell(valuetype="string", stylename="s")
tc.addElement(P(text=header))
tr.addElement(tc)
table.addElement(tr)
for row in self.sheet_data[name]["rows"]:
tr = TableRow()
c = 0
for col in row:
if c >= len(self.sheet_data[name]["colours"]):
cell_format = "p"
else:
cell_format = self.sheet_data[name]["colours"][c]
tc = TableCell(valuetype="string", stylename=cell_format)
if col is None:
col = "NULL"
tc.addElement(P(text=col))
tr.addElement(tc)
c += 1
table.addElement(tr)
self.doc.spreadsheet.addElement(table)
def convert_FFPtable_USO(path):
name = "FFPtable.uso"
table = Table(name=name)
with open(path) as fin:
for i in range(2):
table.addElement(TableColumn())
for line in fin.readlines():
line = line.split()
row = TableRow()
for item in line:
cell = TableCell(valuetype="float", value=item)
row.addElement(cell)
table.addElement(row)
return table
def addTable(self, content, cell_style, column_styles=[]):
cell_style = getattr(self, cell_style, None)
table = Table()
for style in column_styles:
if "stylename" in style.keys():
style["stylename"] = getattr(self, style["stylename"], None)
table.addElement(TableColumn(**style))
for row in content:
tr = TableRow()
table.addElement(tr)
for cell in row:
tc = TableCell()
tr.addElement(tc)
p = P(stylename=cell_style, text=cell)
tc.addElement(p)
self.document.text.addElement(table)
def write_output_data_to_ods(self, output_filename):
"""Write output data in ODS file.
:param output_filename: Path of the output_filename.
"""
ods_file = OpenDocumentSpreadsheet()
table = Table(name=self.output_sheet_name)
for row in self.output_data:
table_row = TableRow()
for val in row:
table_cell = TableCell(valuetype="string")
table_cell.addElement(P(text=val))
table_row.addElement(table_cell)
table.addElement(table_row)
ods_file.spreadsheet.addElement(table)
ods_file.save(output_filename)
def write_text():
"""Write to output file ordinary elements.
This function is called every tame, we collect whole paragraph or block of elements in 'string_to_write'
We write every block or paragraph in it's own cell in the first column of output file.
After writing we shift down current row and clean 'string_to_write' in order to collect next elements.
"""
global string_to_write
global header_level
global ordered
global bullet
global table
global separator
global content
row = TableRow()
cell = TableCell()
if header_level != 0 and header_level > 0:
if header_level > (len(header) -
1): # if there are headers with lvl bigger than 2
for i in range(
len(header), header_level +
1): # creating names for headers with lvl bigger than 2
header.append('header' + str(i))
add_style(cell, header[header_level])
if header_level == separator: # if separator was set, we will create new sheet in document
if table.hasChildNodes():
write_sheet()
table = Table(
name=string_to_write
) # creating new sheet with separating header as name
else:
add_style(cell, simple_text)
if bullet:
string_to_write = '- ' + string_to_write
if ordered > 0:
string_to_write = str(ordered) + ') ' + string_to_write
ordered = ordered + 1
content.addText(string_to_write)
cell.addElement(content)
content = P()
count_height(row, cell)
row.addElement(cell)
table.addElement(row)
string_to_write = ''
def create_odf_table_row(data, first=""):
"""
returns a odt table row that contains the passed data in odf table cells
input:
first style scheme of the first row's cells
output:
row the created table row containing cells with corresponding data
"""
row = TableRow()
for i, item in enumerate(data):
# we need to distinguish between first column, middle columns and last
# columns. The first and the last have outer borders, while the middle
# have not. If we draw the first row, skip this and use the passed
# style.
if not first:
# first
if i == 0:
style = "col_left"
# last
elif i == (len(data) - 1):
style = "col_right"
# middle
else:
style = "col_middle"
else:
style = first
logger.debug("cell content (i=%d):%s, style=%s", i, item, style)
cell = TableCell(valuetype='string', stylename=style)
cell.addElement(P(text=item, stylename="default"))
row.addElement(cell)
return row
def addtable(self, name, hdr):
self.table = Table(name=str(name))
self.doc.spreadsheet.addElement(self.table)
for h in hdr[:-2]:
tcol = TableColumn(stylename=self.colStyle30)
self.table.addElement(tcol)
tcol = TableColumn(stylename=self.colStyle40)
self.table.addElement(tcol)
tcol = TableColumn(stylename=self.colStyle200)
self.table.addElement(tcol)
self.exrow=1
tr = TableRow()
for item in hdr:
tc = TableCell(stylename="hdrStyle") #empty cell
tr.addElement(tc)
p = P(text=item)
tc.addElement(p)
self.table.addElement(tr)
return
def write_image(image):
"""Write to output file image elements.
Since, element with title 'Image' has special structure of 'c'(Content) field, that looks like:
[[0], [1], [2]]
where:
[0] - list of attributes: identifier, classes, key-value pairs:
['id', [], [ ... , ['weight', '...in'], ['height', '...in'], ... ] - we get sizes there.
[1] - caption.
[2] - ['src', 'title'] - source and title of image.
we should parse it especially.
Args:
image - element with title 'Image'.
"""
global image_counter
global saved_hr
if image_counter == -1:
return
if image_counter == 0:
saved_hr = load_images(args.input, ods)
if len(saved_hr) == 0:
image_counter = -1
return
if string_to_write:
write_text()
row = TableRow()
cell = TableCell()
w, h = count_size(image['c'][0][2], row)
frame = Frame(width=w, height=h)
img = Image(href=saved_hr[image_counter])
table.addElement(row)
row.addElement(cell)
cell.addElement(frame)
frame.addElement(img)
image_counter = image_counter + 1
def as_table(self):
"""Convert to a odf.table.Table object"""
t = Table(name=self.name)
# Find out max row and col
maxcol = max(col for col, row in self._contents.keys())
maxrow = max(row for col, row in self._contents.keys())
# Add column styles
for c in range(0, maxcol + 1):
s = self._columnstyles.get(c, None)
if s:
t.addElement(TableColumn(stylename=s))
else:
t.addElement(TableColumn())
for row in range(0, maxrow + 1):
tr = TableRow()
t.addElement(tr)
for col in range(0, maxcol + 1):
cell = self._contents.get((col, row), None)
if cell:
tr.addElement(cell)
else:
tr.addElement(TableCell())
return t
def generate_row(datetime, location, extra, acolytes):
# Datum und Uhrzeit formatieren
date_string = datetime.strftime("%d.%m.%Y")
time_string = datetime.strftime("%H:%M")
# Neue TableRow erstellen und einfügen
row = TableRow()
table.addElement(row)
# Datum - Zeit Zelle anlegen
date_time_cell = TableCell()
date_time_cell.addElement(P(stylename=center, text=date_string))
date_time_cell.addElement(P(stylename=center_bold, text=time_string))
# Ort - Information Zelle anlegen
location_extra_cell = TableCell()
location_extra_cell.addElement(P(stylename=center_bold, text=location))
location_extra_cell.addElement(P(stylename=center, text=extra))
# Messdiener Zelle anlegen
acolytes_cell = TableCell()
# Messdiener nach Rolle sortiert auflisten
for role_name in acolytes:
p = P(stylename=left)
p.addElement(Span(stylename=bold_style, text=f"{role_name}: "))
p.addText(text=', '.join(acolytes[role_name]))
acolytes_cell.addElement(p)
# Zellen zur TableRow hinzufügen
row.addElement(date_time_cell)
row.addElement(location_extra_cell)
row.addElement(acolytes_cell)
# TableRow zurückgeben
return row
def addrow(row, table, tablecontents):
tr = TableRow()
table.addElement(tr)
for rr in row:
if str(type(rr)) == "<type 'unicode'>":
tc = TableCell(valuetype="string")
tr.addElement(tc)
p = P(stylename=tablecontents, text=rr)
tc.addElement(p)
elif str(type(rr)) == "<type 'float'>" or str(
type(rr)) == "<type 'int'>" or str(
type(rr)) == "<class 'decimal.Decimal'>":
tc = TableCell(valuetype="float", value=rr)
tr.addElement(tc)
elif str(type(rr)) == "<type 'NoneType'>":
tc = TableCell(valuetype="string")
tr.addElement(tc)
p = P(stylename=tablecontents, text=unicode(' ', PWENC))
tc.addElement(p)
elif str(type(rr)) == "<type 'datetime.datetime'>":
tc = TableCell(valuetype="string")
tr.addElement(tc)
p = P(stylename=tablecontents,
text=unicode(rr.strftime("%d.%m.%Y"), PWENC))
tc.addElement(p)
else:
print str(type(rr)), rr
tc = TableCell(valuetype="string")
tr.addElement(tc)
p = P(stylename=tablecontents, text=unicode(rr, PWENC))
tc.addElement(p)
tr.addElement(tc)
tr.addElement(tc)
return table
def to_ods(self, *selection):
if not ODFLIB_INSTALLED:
raise ODFLIBNotInstalled(_('odfpy not installed.'))
if self.fcn_list:
stat_list = self.fcn_list[:]
order_text = " Ordered by: " + self.sort_type + '\n'
else:
stat_list = self.stats.keys()
order_text = " Random listing order was used\n"
for s in selection:
stat_list, __ = self.eval_print_amount(s, stat_list, '')
spreadsheet = OpenDocumentSpreadsheet()
table = Table(name="Profile")
for fn in self.files:
tcf = TableCell()
tcf.addElement(P(text=fn))
trf = TableRow()
trf.addElement(tcf)
table.addElement(trf)
tc_summary = TableCell()
summary_text = '%d function calls (%d primitive calls) in %.6f \
seconds' % (self.total_calls, self.prim_calls,
self.total_tt)
tc_summary.addElement(P(text=summary_text))
tr_summary = TableRow()
tr_summary.addElement(tc_summary)
table.addElement(tr_summary)
tc_order = TableCell()
tc_order.addElement(P(text=order_text))
tr_order = TableRow()
tr_order.addElement(tc_order)
table.addElement(tr_order)
tr_header = TableRow()
tc_cc = TableCell()
tc_cc.addElement(P(text='Total Call Count'))
tr_header.addElement(tc_cc)
tc_pc = TableCell()
tc_pc.addElement(P(text='Primitive Call Count'))
tr_header.addElement(tc_pc)
tc_tt = TableCell()
tc_tt.addElement(P(text='Total Time(seconds)'))
tr_header.addElement(tc_tt)
tc_pc = TableCell()
tc_pc.addElement(P(text='Time Per call(seconds)'))
tr_header.addElement(tc_pc)
tc_ct = TableCell()
tc_ct.addElement(P(text='Cumulative Time(seconds)'))
tr_header.addElement(tc_ct)
tc_pt = TableCell()
tc_pt.addElement(P(text='Cumulative Time per call(seconds)'))
tr_header.addElement(tc_pt)
tc_nfl = TableCell()
tc_nfl.addElement(P(text='filename:lineno(function)'))
tr_header.addElement(tc_nfl)
table.addElement(tr_header)
for func in stat_list:
cc, nc, tt, ct, __ = self.stats[func]
tr_header = TableRow()
tc_nc = TableCell()
tc_nc.addElement(P(text=nc))
tr_header.addElement(tc_nc)
tc_pc = TableCell()
tc_pc.addElement(P(text=cc))
tr_header.addElement(tc_pc)
tc_tt = TableCell()
tc_tt.addElement(P(text=tt))
tr_header.addElement(tc_tt)
tc_tpc = TableCell()
tc_tpc.addElement(P(text=(None if nc == 0 else float(tt) / nc)))
tr_header.addElement(tc_tpc)
tc_ct = TableCell()
tc_ct.addElement(P(text=ct))
tr_header.addElement(tc_ct)
tc_tpt = TableCell()
tc_tpt.addElement(P(text=(None if cc == 0 else float(ct) / cc)))
tr_header.addElement(tc_tpt)
tc_nfl = TableCell()
tc_nfl.addElement(P(text=func))
tr_header.addElement(tc_nfl)
table.addElement(tr_header)
spreadsheet.spreadsheet.addElement(table)
tmp_ods = tempfile.TemporaryFile()
spreadsheet.write(tmp_ods)
tmp_ods.seek(0)
data = tmp_ods.read()
os.close(tmp_ods)
return data
ns2.addElement(Map(condition="value()>=0", applystylename="positive-AUD"))
textdoc.styles.addElement(ns2)
# Create automatic style for the price cells.
moneycontents = Style(name="ce1",
family="table-cell",
parentstylename=tablecontents,
datastylename="main-AUD")
textdoc.automaticstyles.addElement(moneycontents)
# Start the table, and describe the columns
table = Table(name="Currency colours")
# Create a column (same as <col> in HTML) Make all cells in column default to currency
table.addElement(TableColumn(stylename=widewidth, defaultcellstylename="ce1"))
# Create a row (same as <tr> in HTML)
tr = TableRow()
table.addElement(tr)
# Create a cell with a negative value. It should show as red.
cell = TableCell(valuetype="currency", currency="AUD", value="-125")
cell.addElement(P(text=u"$-125.00")) # The current displayed value
tr.addElement(cell)
# Create a row (same as <tr> in HTML)
tr = TableRow()
table.addElement(tr)
# Create another cell but with a positive value. It should show in black
cell = TableCell(valuetype="currency", currency="AUD", value="123")
cell.addElement(P(text=u"$123.00")) # The current displayed value
tr.addElement(cell)
textdoc.spreadsheet.addElement(table)
