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 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 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 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 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 output_reqset(self, reqset, reqscont):
# Because of a problem with the current OpenOffice versions,
# there is the need to sometimes arrange requirements as rows
# and sometimes as columns:
# It is not possible to define the range of a list input as a
# row: it must be a column.
# The order dictionary holds the number - which can be
# computed in a row or column.
def create_reqs_index(srqes):
sreqs_index = {}
cnt = 0
for req in sreqs:
sreqs_index[req] = cnt
cnt += 1
return sreqs_index
# The topological sort is needed.
sreqs = topological_sort(self.topic_set.reqset)
# Create the row / column index of each requirement
self.sreqs_index = create_reqs_index(sreqs)
# Create and save the document
calcdoc = OpenDocumentSpreadsheet()
self.create_meta(calcdoc, reqscont)
self.create_styles(calcdoc)
self.create_costs_sheet(calcdoc, sreqs)
self.create_deps_sheet(calcdoc, sreqs)
self.create_sums_sheet(calcdoc, sreqs)
self.create_constants_sheet(calcdoc)
self.create_result_sheet(calcdoc, sreqs)
calcdoc.save(self.output_filename, True)
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("TEST.odt")
self.saved = True
d = load("TEST.odt")
result = d.contentxml()
self.assertNotEqual(-1, result.find(u'''<number:percentage-style'''))
self.assertNotEqual(-1, result.find(u'''style:data-style-name="N11"'''))
self.assertNotEqual(-1, result.find(u'''style:name="pourcent"'''))
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 _toODSFile(odf_table_list, filename):
doc = OpenDocumentSpreadsheet()
for t in odf_table_list:
doc.spreadsheet.addElement(t)
doc.save('/tmp/' + filename, True)
return file('/tmp/' + filename + '.ods')
def _toODSFile(odf_table_list, filename):
doc = OpenDocumentSpreadsheet()
for t in odf_table_list:
doc.spreadsheet.addElement(t)
doc.save('/tmp/' + filename, True)
return file('/tmp/' + filename + '.ods')
class ODSOutput(SpreadsheetOutput):
def open(self):
self.workbook = OpenDocumentSpreadsheet()
def _make_cell(self, value):
""" Util for creating an ods cell """
if value:
try:
# See if value parses as a float
cell = odf.table.TableCell(valuetype="float",
value=float(value))
except ValueError:
cell = odf.table.TableCell(valuetype="string")
else:
cell = odf.table.TableCell(valuetype="Nonetype")
p = odf.text.P(text=value)
cell.addElement(p)
return cell
def write_sheet(self, sheet_name, sheet):
worksheet = odf.table.Table(name=sheet_name)
sheet_header = list(sheet)
header_row = odf.table.TableRow()
for header in sheet_header:
header_row.addElement(self._make_cell(header))
worksheet.addElement(header_row)
for sheet_line in sheet.lines:
row = odf.table.TableRow()
for header in sheet_header:
value = sheet_line.get(header)
if isinstance(value, str):
new_value = ILLEGAL_CHARACTERS_RE.sub("", value)
if new_value != value:
warn(
_("Character(s) in '{}' are not allowed in a spreadsheet cell. Those character(s) will be removed"
).format(value),
DataErrorWarning,
)
value = new_value
row.addElement(self._make_cell(value))
worksheet.addElement(row)
self.workbook.spreadsheet.addElement(worksheet)
def close(self):
self.workbook.save(self.output_name)
def main():
input_dir = os.path.join(PARMA_DIR, "input")
doc = OpenDocumentSpreadsheet()
table_list = []
table_list.append(
convert_FFPtable_day(os.path.join(input_dir, "FFPtable.day")))
table_list.append(
convert_FFPtable_USO(os.path.join(input_dir, "FFPtable.uso")))
for table in table_list:
doc.spreadsheet.addElement(table)
doc.save("parma.ods")
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)
class SpreadSheet(object):
def __init__(self):
self._document = OpenDocumentSpreadsheet()
self._sheets = {}
def sheet(self, name):
if name not in self._sheets:
self._sheets[name] = Sheet(name)
self._document.spreadsheet.addElement(self._sheets[name]._table)
return self._sheets[name]
def add_style(self, name, family, styles, **kwargs):
style = Style(name=name, family=family, **kwargs)
for v in styles:
style.addElement(v)
self._document.automaticstyles.addElement(style)
def add_font(self, fontface):
self._document.fontfacedecls.addElement(fontface)
def save(self, buf):
return self._document.save(buf)
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)
class OdsWriter(Writer):
def write(self):
super().write()
self.doc = OpenDocumentSpreadsheet()
self.cell_formats = {}
for key, value in self.colours.items():
style = Style(name=key, family="table-cell")
style.addElement(TableCellProperties(backgroundcolor="#" + value))
self.doc.automaticstyles.addElement(style)
self.cell_formats[key] = style
for sheet in self.sheets:
self.write_table(sheet)
self.doc.save(self.filename, True)
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)
ods_doc = OpenDocumentSpreadsheet() # Create a new Table/Sheet sheet = Table(name="odfpy_ods") # Create a new empty row tablerow = TableRow() # Create 3 new cells with different value type cell1 = TableCell(valuetype="string") cell1.addElement(P(text="Hello World !")) cell2 = TableCell(valuetype="float", value=1) cell3 = TableCell(valuetype="currency", currency="CHF", value="-8100") # Add these cells to the row tablerow.addElement(cell1) tablerow.addElement(cell2) tablerow.addElement(cell3) # Add the row to the table sheet.addElement(tablerow) # Add the table/sheet to the ods document ods_doc.spreadsheet.addElement(sheet) # Save the document ods_doc.save(r"C:\FichiersLocauxRevit\odfpy.ods") # Load an ods document ods_doc = load(r"C:\FichiersLocauxRevit\odfpy.ods") # Get first sheet sheet = ods_doc.getElementsByType(Table)[0] # Get cell a i, j (row, column) i, j = 1, 2 row = sheet.getElementsByType(TableRow)[i - 1] cell = row.getElementsByType(TableCell)[j - 1] print cell.value
def save(telephoneDir, subdivision, collaborator, number, telephoneType):
textdoc = OpenDocumentSpreadsheet()
tablecontents = Style(name="Table Contents", family="paragraph")
tablecontents.addElement(
ParagraphProperties(numberlines="false", linenumber="0"))
textdoc.styles.addElement(tablecontents)
style2 = Style(name="style2", family="table-column")
style2.addElement(TableColumnProperties(columnwidth="2cm"))
textdoc.automaticstyles.addElement(style2)
style6 = Style(name="style6", family="table-column")
style6.addElement(TableColumnProperties(columnwidth="6cm"))
textdoc.automaticstyles.addElement(style6)
table = Table(name=u"Подразделения")
table.addElement(TableColumn(numbercolumnsrepeated=2, stylename=style6))
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)
row((u"подразделение", u"головное подразделение"))
row((telephoneDir.subdivision.name.decode("utf-8"), ""))
def write(subdivision):
for s in subdivision.subdivisions:
row((s.name.decode("utf-8"), subdivision.name.decode("utf-8")))
write(s)
write(telephoneDir.subdivision)
textdoc.spreadsheet.addElement(table)
table = Table(name=u"Телефонный справочник")
table.addElement(TableColumn(numbercolumnsrepeated=2, stylename=style2))
table.addElement(TableColumn(numbercolumnsrepeated=4, stylename=style6))
row((u"телефон", u"код сотр.", u"фамилия", u"имя", u"отчество",
u"подразделение", u"тип тел."))
def find(c, subdivision):
if c in subdivision.collaborators:
return subdivision.name.decode("utf-8")
else:
for s in subdivision.subdivisions:
r = find(c, s)
if r:
return r
subdivision = int(subdivision)
telephoneType = int(telephoneType)
collaborator = collaborator.encode('utf-8')
number = number.encode('utf-8')
if not subdivision:
lambdaSubdivision = lambda rec: True
else:
subdivisions = list(sorted(telephoneDir.subdivision.iterSubdivision()))
subdivisions.insert(0, 'все')
s = subdivisions[subdivision]
lambdaSubdivision = lambda rec: rec.collaborator in s
if not collaborator:
lambdaCollaborator = lambda rec: True
else:
lambdaCollaborator = lambda rec: str(rec.collaborator)[0:len(
collaborator)] == collaborator
if not number:
lambdaNumber = lambda rec: True
else:
lambdaNumber = lambda rec: str(rec.telephone.number)[0:len(number)
] == number
if not telephoneType:
lambdaTelephoneType = lambda rec: True
else:
telephoneTypes = list(sorted(telephoneDir.telephones.telephoneTypes))
telephoneTypes.insert(0, 'все')
t = telephoneTypes[telephoneType]
lambdaTelephoneType = lambda rec: rec.telephone.type == t
tmpDir = list(sorted(telephoneDir))
tmpDir = filter(lambda telephone: lambdaSubdivision(telephone) and \
lambdaCollaborator(telephone) and \
lambdaNumber(telephone) and \
lambdaTelephoneType(telephone), tmpDir)
print subdivision, telephoneType, collaborator, number
for r in tmpDir:
row((r.telephone.number, r.collaborator.code,
r.collaborator.family.decode("utf-8"),
r.collaborator.name.decode("utf-8"),
r.collaborator.patronym.decode("utf-8"),
find(r.collaborator, telephoneDir.subdivision),
r.telephone.type.name.decode("utf-8")))
textdoc.spreadsheet.addElement(table)
textdoc.save("telephonedir.ods")
def create_function(full_path):
textdoc = OpenDocumentSpreadsheet()
textdoc.styles.addElement(self.build_default_style())
textdoc.save(full_path)
class ODSWriter:
def __init__(self):
self.doc = OpenDocumentSpreadsheet()
#styles
self.itemRowStyle1 = Style(name="itemRowStyle", family="table-row")
self.itemRowStyle1.addElement(TableRowProperties(rowheight="7mm"))
self.doc.automaticstyles.addElement(self.itemRowStyle1)
self.itemRowStyle3 = Style(name="itemRowStyle", family="table-row")
self.itemRowStyle3.addElement(TableRowProperties(rowheight="30mm"))
self.doc.automaticstyles.addElement(self.itemRowStyle3)
self.colStyle30 = Style(name="colStyle30", family="table-column")
self.colStyle30.addElement(TableColumnProperties(columnwidth="25mm"))
self.doc.automaticstyles.addElement(self.colStyle30)
self.colStyle40 = Style(name="colStyle40", family="table-column")
self.colStyle40.addElement(TableColumnProperties(columnwidth="40mm"))
self.doc.automaticstyles.addElement(self.colStyle40)
self.colStyle50 = Style(name="colStyle50", family="table-column")
self.colStyle50.addElement(TableColumnProperties(columnwidth="50mm"))
self.doc.automaticstyles.addElement(self.colStyle50)
self.colStyle200 = Style(name="colStyle200", family="table-column")
self.colStyle200.addElement(TableColumnProperties(columnwidth="200mm"))
self.doc.automaticstyles.addElement(self.colStyle200)
self.cellStyle1 = Style(name="cellStyle1",family="table-cell", parentstylename='Standard', displayname="middle")
self.cellStyle1.addElement(ParagraphProperties(textalign="center"))
self.cellStyle1.addElement(TableCellProperties(verticalalign="middle"))
self.cellStyle1.addElement(TableCellProperties(wrapoption="wrap"))
self.doc.automaticstyles.addElement(self.cellStyle1)
self.hdrStyle = Style(name="hdrStyle",family="table-cell", parentstylename='Standard', displayname="middle")
self.hdrStyle.addElement(ParagraphProperties(textalign="center"))
self.hdrStyle.addElement(TextProperties(fontweight="bold"))
self.hdrStyle.addElement(TableCellProperties(verticalalign="middle"))
self.doc.automaticstyles.addElement(self.hdrStyle)
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 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 save(self, ofname):
self.doc.save(ofname)
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.mktemp('.ods', 'stats')
spreadsheet.save(tmp_ods, False)
data = open(tmp_ods).read()
os.remove(tmp_ods)
return data
def odsResponse(inscriptions, noninscrits):
"""
fabrique un objet de type HttpResponse qui comporte un tableur au format
ODS, avec les exportations d'une "barrette" d'AP.
@param inscriptions un objet issu de Inscription.objects.all()
@param noninscrits une liste d'Etudiants
@return un objet de type HttpResponse
"""
response = HttpResponse(content_type='application/vnd.oasis.opendocument.spreadsheet')
now=timezone.now()
filename="aperho-{}.ods".format(now.strftime("%Y%m%d-%H%M"))
response['Content-Disposition'] = 'attachment; filename={}'.format(filename)
doc = OpenDocumentSpreadsheet()
# 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"))
doc.styles.addElement(tablecontents)
# Create automatic styles for the column widths.
# We want two different widths, one in inches, the other one in metric.
# ODF Standard section 15.9.1
widthshort = Style(name="Wshort", family="table-column")
widthshort.addElement(TableColumnProperties(columnwidth="1.7cm"))
doc.automaticstyles.addElement(widthshort)
widthwide = Style(name="Wwide", family="table-column")
widthwide.addElement(TableColumnProperties(columnwidth="1.5in"))
doc.automaticstyles.addElement(widthwide)
# Start the table, and describe the columns
table = Table(name="Inscriptions")
table.addElement(TableColumn(numbercolumnsrepeated=3,stylename=widthwide))
tr = TableRow()
table.addElement(tr)
for title in ['id', 'Eleve_nom', 'Eleve_prenom', 'Eleve_classe', 'Professeur', 'Salle', 'Heure', 'Duree', 'Public_designe', 'Resume','Detail','Autres']:
tc = TableCell()
tr.addElement(tc)
p = P(stylename=tablecontents,text=title)
tc.addElement(p)
for i in inscriptions:
tr = TableRow()
table.addElement(tr)
for val in [i.pk, i.etudiant.nom, i.etudiant.prenom, i.etudiant.classe, i.cours.enseignant.nom, i.cours.enseignant.salle, i.cours.horaire, i.cours.formation.duree, i.cours.formation.public_designe, i.cours.formation.titre, i.cours.formation.contenu]:
tc = TableCell()
tr.addElement(tc)
p = P(stylename=tablecontents,text=str(val))
tc.addElement(p)
## write something in the last column (Autres)
tc = TableCell()
tr.addElement(tc)
p = P(stylename=tablecontents,text=rdvOrientation(i))
tc.addElement(p)
for e in noninscrits:
tr = TableRow()
table.addElement(tr)
for val in [0, e.nom, e.prenom, e.classe, '', '', '', '', '', '', '','']:
tc = TableCell()
tr.addElement(tc)
p = P(stylename=tablecontents,text=str(val))
tc.addElement(p)
doc.spreadsheet.addElement(table)
output=BytesIO()
doc.save(output)
response.write(output.getvalue())
return response
def save(self, filename, i_max = None, j_max = None): ''' save table in ods format ''' if not i_max: i_max = self.table.i_max if not j_max: j_max = self.table.j_max # update cells text self.table.updateTable(i_max, j_max) # create new odf spreadsheet odfdoc = OpenDocumentSpreadsheet() # set direction style rtl = Style(name = "dir", family = "table") if self.table.direction == 'rtl': rtl.addElement(TableProperties(writingmode="rl-tb")) odfdoc.automaticstyles.addElement(rtl) # create the table table = Table(name = "sheet 1", stylename = 'dir') # default style ts = Style(name = "ts", family = "table-cell") ts.addElement(TextProperties(fontfamily = SodsCell().font_family, fontsize = SodsCell().font_size)) odfdoc.styles.addElement(ts) # create columns for j in range(1, j_max): colname = "col" + str(j) c = self.table.getCellAt(0, j) width = c.column_width cs = Style(name = colname, family = "table-column") cs.addElement(TableColumnProperties(columnwidth = width, breakbefore = "auto")) odfdoc.automaticstyles.addElement(cs) table.addElement(TableColumn(stylename = colname, defaultcellstylename = "ts")) # make sure values are up to date # loop and update the cells value for i in range(1, i_max): # create new ods row tr = TableRow() table.addElement(tr) # create default data styles for dates and numbers ncs = NumberStyle(name="ncs") ncs.addElement(Number(decimalplaces="2", minintegerdigits="1", grouping="true")) odfdoc.styles.addElement(ncs) ncs2 = NumberStyle(name="ncs2") ncs2.addElement(Number(decimalplaces="0", minintegerdigits="1", grouping="false")) odfdoc.styles.addElement(ncs2) dcs = DateStyle(name="dcs") dcs.addElement(Year(style='long')) dcs.addElement(Text(text = '-')) dcs.addElement(Month(style='long')) dcs.addElement(Text(text = '-')) dcs.addElement(Day(style='long')) odfdoc.styles.addElement(dcs) for j in range(1, j_max): # update the cell text and condition cell = self.table.encodeColName(j) + str(i) c = self.table.getCellAt(i, j) # chose datastylename if c.value_type == 'date': datastylename = "dcs" else: if c.format == "": datastylename = "ncs2" if c.format == "#,##0.00": datastylename = "ncs" # get cell style id if (c.condition): style_id = (datastylename + c.color + c.font_size + c.font_family + c.background_color + c.border_top + c.border_bottom + c.border_left + c.border_right + c.condition_color + c.condition_background_color) else: style_id = (datastylename + c.color + c.font_size + c.font_family + c.background_color + c.border_top + c.border_bottom + c.border_left + c.border_right) # set ods style style_name = self.getStyle(c, cell, datastylename, style_id, odfdoc) # create new ods cell if (c.formula and c.formula[0] == '=' and c.formula[:4] != '=uni'): if self.table.isFloat(c.value): tc = TableCell(valuetype = c.value_type, formula = c.formula, value = float(c.value), stylename = style_name) else: tc = TableCell(valuetype = c.value_type, formula = c.formula, value = 0, stylename = style_name) elif (c.value_type == 'date'): tc = TableCell(valuetype = c.value_type, datevalue = c.date_value, stylename = style_name) elif (c.value_type == 'float') and self.table.isFloat(c.value): tc = TableCell(valuetype = c.value_type, value = float(c.value), stylename = style_name) else: tc = TableCell(valuetype = 'string', stylename = style_name) # set ods text tc.addElement(P(text = str(escape(c.text), 'utf-8'))) tr.addElement(tc) odfdoc.spreadsheet.addElement(table) odfdoc.save(filename)
def btExportarClick(self, widget):
count = self.tvSolicitudes.get_selection().count_selected_rows()
#Exportamos todo el treeview si no se han seleccionado filas.
if count == 0:
self.tvSolicitudes.get_selection().select_all()
tree,iter = self.tvSolicitudes.get_selection().get_selected_rows()
textdoc = OpenDocumentSpreadsheet()
# Start the table, and describe the columns
table = Table(name="Solicitudes")
for i in iter: #esto funciona aquí, porque no voy eliminando filas del treeview. Por eso en el botón eliminar tuve que hacerlo distinto.
expediente = tree.get_value(tree.get_iter(i), 1)
persona = tree.get_value(tree.get_iter(i), 4)
fecha = tree.get_value(tree.get_iter(i), 0)
caja = tree.get_value(tree.get_iter(i), 2)
lugar = tree.get_value(tree.get_iter(i), 3)
# Create a row (same as <tr> in HTML)
tr = TableRow()
table.addElement(tr)
# Create a cell
cell = TableCell()
cell.addElement(P(text=expediente)) # The current displayed value
tr.addElement(cell)
cell4 = TableCell()
cell4.addElement(P(text=caja))
tr.addElement(cell4)
cell5 = TableCell()
cell5.addElement(P(text=lugar))
tr.addElement(cell5)
cell2 = TableCell()
cell2.addElement(P(text=persona))
tr.addElement(cell2)
cell3 = TableCell()
cell3.addElement(P(text=fecha))
tr.addElement(cell3)
#exportamos las filas seleccionadas
else:
tree,iter = self.tvSolicitudes.get_selection().get_selected_rows()
# ret = []
# for i in iter:
# ret.append(tree.get_value(tree.get_iter(i), 0))
textdoc = OpenDocumentSpreadsheet()
# Start the table, and describe the columns
table = Table(name="Solicitudes")
for i in iter: #esto funciona aquí, porque no voy eliminando filas del treeview. Por eso en el botón eliminar tuve que hacerlo distinto.
expediente = tree.get_value(tree.get_iter(i), 1)
persona = tree.get_value(tree.get_iter(i), 4)
fecha = tree.get_value(tree.get_iter(i), 0)
caja = tree.get_value(tree.get_iter(i), 2)
lugar = tree.get_value(tree.get_iter(i), 3)
# Create a row (same as <tr> in HTML)
tr = TableRow()
table.addElement(tr)
# Create a cell
cell = TableCell()
cell.addElement(P(text=expediente)) # The current displayed value
tr.addElement(cell)
cell4 = TableCell()
cell4.addElement(P(text=caja))
tr.addElement(cell4)
cell5 = TableCell()
cell5.addElement(P(text=lugar))
tr.addElement(cell5)
cell2 = TableCell()
cell2.addElement(P(text=persona))
tr.addElement(cell2)
cell3 = TableCell()
cell3.addElement(P(text=fecha))
tr.addElement(cell3)
textdoc.spreadsheet.addElement(table)
textdoc.save("Solicitudes_de_Expediente.ods")
if sys.platform == 'linux2':
os.system("xdg-open Solicitudes_de_Expediente.ods &")
else:
os.system("start soffice --calc Solicitudes_de_Expediente.ods &")
table.addElement(tr)
addcell(tr, account[0]['code'], lestyle)
addcell(tr, account[0]['name'], lestyle)
addcell(tr, account[0]['type'], lestyle)
addcell(tr, len(search_child), lestyle)
addcell(tr, account[0]['balance'], lestyle)
# print account[0]['code'],account[0]['name'].encode('utf-8')," "*(65-len(account[0]['name']))," type : ",account[0]['type'],' enfants : ', len(search_child),account[0]['balance']
for child_id in search_child:
account = sock.execute(base, uid, password, 'account.account', 'read', [child_id],
['code', 'name', 'type', 'balance'])
search_child = sock.execute(base, uid, password, 'account.account', 'search',
[('active', 'in', ('True', 'False')), ('parent_id', '=', child_id)], 0,
1000)
row += 1
tr = TableRow()
table.addElement(tr)
addcell(tr, "", lestyle)
addcell(tr, account[0]['code'], lestyle)
addcell(tr, account[0]['name'], lestyle)
addcell(tr, account[0]['type'], lestyle)
addcell(tr, len(search_child), lestyle)
addcell(tr, account[0]['balance'], lestyle)
#print "\t",account[0]['code'],account[0]['name'].encode('utf-8')," "*(65-len(account[0]['name']))," type : ",account[0]['type'],' enfants : ', len(search_child),account[0]['balance']
if trouve:
calc.spreadsheet.addElement(table)
calc.save('/home/evernichon/controle_vue', True)
def getValues(self, **kw):
"""
a routine to get measured values as a useful file
@param kw keywords; allowed keywords are:
- mode: the way you want to get the values
The default mode is "ascii", which means that
values are formated as ascii lines (space-separated numbers).
<BR>
Other supported modes are not yet implemented
@return a stream with the relevant MIMEtype.
"""
filename="values-{0}".format(time.strftime("%Y-%m-%d_%H_%M_%S"))
if 'mode' in kw:
mode=kw['mode']
else:
#mode='ascii'
mode='ods'
if mode=="ascii":
## define response headers
cherrypy.response.headers["Content-Type"]="text/ascii;charset=utf-8"
cherrypy.response.headers['Content-Disposition'] = 'attachment; filename={}.txt'.format(filename)
## send the data
if self.mtype=='t,v':
result=""
t,v = self.measurements
for i in range(len(t)):
result+="{0:f} {1:f}\n".format(t[i], v[i])
return result
else:
return "mode = '%s', measurement type '%s' not supported." %(mode, self.mtype)
elif mode=="ods":
## define response headers
cherrypy.response.headers["Content-Type"]="application/vnd.oasis.opendocument.spreadsheet"
cherrypy.response.headers['Content-Disposition'] = 'attachment; filename={}.ods'.format(filename)
## send the data
if self.mtype=='t,v':
doc = OpenDocumentSpreadsheet()
# Start the table, and describe the columns
table = Table(name="Expeyes-Jr {0}".format(time.strftime("%Y-%m-%d %Hh%Mm%Ss")))
## column titles
tr = TableRow()
table.addElement(tr)
tc = TableCell()
tr.addElement(tc)
p = P(text='t (ms)')
tc.addElement(p)
tc = TableCell()
tr.addElement(tc)
input=self.inp
for name in ExpPage.expeyes_inputs:
if ExpPage.expeyes_inputs[name]== self.inp:
input=name
break
p = P(text=input+' (V)')
tc.addElement(p)
## write values
t,v=self.measurements
for i in range(len(t)):
tr = TableRow()
table.addElement(tr)
tc = TableCell(valuetype="float", value=str(t[i]))
tr.addElement(tc)
tc = TableCell(valuetype="float", value=str(v[i]))
tr.addElement(tc)
doc.spreadsheet.addElement(table)
result=io.BytesIO()
doc.save(result)
return result.getvalue()
else:
return "mode = '%s', measurement type '%s' not supported." %(mode, self.mtype)
return "non-supported mode %s" %mode
if number_rows_spanned > 1:
first_cell.setAttribute("numberrowsspanned", number_rows_spanned)
for error in errors:
tr = TableRow()
tc = TableCell()
tc.addElement(P(text=error))
table.addElement(tr)
tr.addElement(tc)
for examinee in undefined:
tr = TableRow()
table.addElement(tr)
tc = TableCell(stylename=middle_center)
tr.addElement(tc)
tc.addElement(P(text=undefined[examinee][0]))
tc = TableCell(stylename=middle_center)
tr.addElement(tc)
tc = TableCell(stylename=middle_left)
tr.addElement(tc)
tc.addElement(P(text=examinee))
for examiner in homogenize(undefined[examinee][1]):
tc = TableCell(stylename=middle_center)
tr.addElement(tc)
tc.addElement(P(text=examiner))
output.spreadsheet.addElement(table)
name, ext = splitext(argv[1])
output.save(name+"-timetable"+ext)
def btExportarClick(self, widget):
count = self.tvSolicitudes.get_selection().count_selected_rows()
#Exportamos todo el treeview si no se han seleccionado filas.
if count == 0:
self.tvSolicitudes.get_selection().select_all()
tree,iter = self.tvSolicitudes.get_selection().get_selected_rows()
textdoc = OpenDocumentSpreadsheet()
# Start the table, and describe the columns
table = Table(name="Solicitudes")
for i in iter: #esto funciona aquí, porque no voy eliminando filas del treeview. Por eso en el botón eliminar tuve que hacerlo distinto.
expediente = tree.get_value(tree.get_iter(i), 1)
persona = tree.get_value(tree.get_iter(i), 4)
fecha = tree.get_value(tree.get_iter(i), 0)
caja = tree.get_value(tree.get_iter(i), 2)
lugar = tree.get_value(tree.get_iter(i), 3)
# Create a row (same as <tr> in HTML)
tr = TableRow()
table.addElement(tr)
# Create a cell
cell = TableCell()
cell.addElement(P(text=expediente)) # The current displayed value
tr.addElement(cell)
cell4 = TableCell()
cell4.addElement(P(text=caja))
tr.addElement(cell4)
cell5 = TableCell()
cell5.addElement(P(text=lugar))
tr.addElement(cell5)
cell2 = TableCell()
cell2.addElement(P(text=persona))
tr.addElement(cell2)
cell3 = TableCell()
cell3.addElement(P(text=fecha))
tr.addElement(cell3)
#exportamos las filas seleccionadas
else:
tree,iter = self.tvSolicitudes.get_selection().get_selected_rows()
# ret = []
# for i in iter:
# ret.append(tree.get_value(tree.get_iter(i), 0))
textdoc = OpenDocumentSpreadsheet()
# Start the table, and describe the columns
table = Table(name="Solicitudes")
for i in iter: #esto funciona aquí, porque no voy eliminando filas del treeview. Por eso en el botón eliminar tuve que hacerlo distinto.
expediente = tree.get_value(tree.get_iter(i), 1)
persona = tree.get_value(tree.get_iter(i), 4)
fecha = tree.get_value(tree.get_iter(i), 0)
caja = tree.get_value(tree.get_iter(i), 2)
lugar = tree.get_value(tree.get_iter(i), 3)
# Create a row (same as <tr> in HTML)
tr = TableRow()
table.addElement(tr)
# Create a cell
cell = TableCell()
cell.addElement(P(text=expediente)) # The current displayed value
tr.addElement(cell)
cell4 = TableCell()
cell4.addElement(P(text=caja))
tr.addElement(cell4)
cell5 = TableCell()
cell5.addElement(P(text=lugar))
tr.addElement(cell5)
cell2 = TableCell()
cell2.addElement(P(text=persona))
tr.addElement(cell2)
cell3 = TableCell()
cell3.addElement(P(text=fecha))
tr.addElement(cell3)
textdoc.spreadsheet.addElement(table)
textdoc.save("Solicitudes_de_Expediente.ods")
if sys.platform == 'linux2':
os.system("xdg-open Solicitudes_de_Expediente.ods &")
else:
os.system("start soffice --calc Solicitudes_de_Expediente.ods &")
widthwide = Style(name="Wwide", family="table-column")
widthwide.addElement(TableColumnProperties(columnwidth="1.5in"))
textdoc.automaticstyles.addElement(widthwide)
# Start the table, and describe the columns
table = Table(name=sqltable)
#table.addElement(TableColumn(numbercolumnsrepeated=4,stylename=widthshort))
#table.addElement(TableColumn(numbercolumnsrepeated=3,stylename=widthwide))
cx = sqlite.connect(sqldb)
cu = cx.cursor()
cu.execute("select * from %s" % sqltable)
for row in cu.fetchall():
tr = TableRow()
table.addElement(tr)
for val in row:
tc = TableCell()
tr.addElement(tc)
if type(val) == type(''):
textval = unicode(val,'utf-8')
else:
textval = str(val)
p = P(stylename=tablecontents,text=textval)
tc.addElement(p)
cx.close()
textdoc.spreadsheet.addElement(table)
textdoc.save(sqltable, True)
def write_report_ods(self,
out_file: str,
header_color: str = "#66ffff") -> None:
"""
Writes a report of all the events in the ics file as an ods. Is possible to optionally specify a background color for the header
:param out_file (string): path for the output ods file
:param header_color (string): background color for the header as hexadecimal (e.g. "#66ffff")
"""
textdoc = OpenDocumentSpreadsheet()
table = Table(name="Events")
# Header
ceX = Style(name="ceX", family="table-cell")
ceX.addElement(
TableCellProperties(backgroundcolor=header_color,
border="0.74pt solid #000000"))
textdoc.styles.addElement(ceX)
tr = TableRow()
table.addElement(tr)
cell = TableCell(valuetype="string", stylename="ceX")
cell.addElement(P(text="title"))
tr.addElement(cell)
cell = TableCell(valuetype="string", stylename="ceX")
cell.addElement(P(text="begin"))
tr.addElement(cell)
cell = TableCell(valuetype="string", stylename="ceX")
cell.addElement(P(text="end"))
tr.addElement(cell)
cell = TableCell(valuetype="string", stylename="ceX")
cell.addElement(P(text="duration"))
tr.addElement(cell)
cell = TableCell(valuetype="string", stylename="ceX")
cell.addElement(P(text="description"))
tr.addElement(cell)
cell = TableCell(valuetype="string", stylename="ceX")
cell.addElement(P(text="created"))
tr.addElement(cell)
cell = TableCell(valuetype="string", stylename="ceX")
cell.addElement(P(text="location"))
tr.addElement(cell)
cell = TableCell(valuetype="string", stylename="ceX")
cell.addElement(P(text="url"))
tr.addElement(cell)
# Content
for ev in self.my_Calendar.events:
tr = TableRow()
(title, begin, end, duration, uid, description, created, location,
url, transparent) = self.__get_fields__(ev)
table.addElement(tr)
cell = TableCell(valuetype="string")
cell.addElement(P(text=title))
tr.addElement(cell)
cell = TableCell()
cell.addElement(P(text=begin.format('YYYY-MM-DD HH:mm:ss ZZ')))
tr.addElement(cell)
cell = TableCell()
cell.addElement(P(text=end.format('YYYY-MM-DD HH:mm:ss ZZ')))
tr.addElement(cell)
cell = TableCell()
cell.addElement(P(text=str(duration)))
tr.addElement(cell)
cell = TableCell(valuetype="string")
cell.addElement(P(text=description))
tr.addElement(cell)
cell = TableCell()
cell.addElement(P(text=created.format('YYYY-MM-DD HH:mm:ss ZZ')))
tr.addElement(cell)
cell = TableCell(valuetype="string")
cell.addElement(P(text=location))
tr.addElement(cell)
cell = TableCell()
link = A(type="simple", href=url, text=url)
p = P()
p.addElement(link)
cell.addElement(p)
tr.addElement(cell)
textdoc.spreadsheet.addElement(table)
textdoc.save(out_file)
if upd:
table_media = None
table_desvio = None
try:
doc = load(out_file + ".ods")
except:
print "File not found? (%s)" % (out_file + ".ods")
sys.exit(2)
for sheet in doc.getElementsByType(Table)[:]:
if sheet.attributes['table:name'] == db_name + "_media":
table_media = sheet
if sheet.attributes['table:name'] == db_name + "_desvio":
table_desvio = sheet
if not (table_media and table_desvio):
table_media = Table(name=db_name + "_media")
table_desvio = Table(name=db_name + "_desvio")
make_body(dir,desc)
doc.spreadsheet.addElement(table_media)
doc.spreadsheet.addElement(table_desvio)
else:
make_body(dir,desc)
doc.save(out_file, True)
else:
doc = OpenDocumentSpreadsheet()
table_media = Table(name=db_name + "_media")
table_desvio = Table(name=db_name + "_desvio")
make_body(dir,desc)
doc.spreadsheet.addElement(table_media)
doc.spreadsheet.addElement(table_desvio)
doc.save(out_file, True)
class oopricing1(StdOutputParams, ExecutorTopicContinuum,
CreateMakeDependencies):
def __setup_coord_lookup(self):
'''Because at some points a requirement will be rendered in a row
and at some other points as a column, there is the need to
access the used cell addresses from integers.
This function creates a map to easily acces the column name by
the column index: 0->A, 1->B, ..., 26->Z, 27->AA, ...
Note: This currently limits the number of requirements which can
be handled with this output module to about 700. If there is a
need for more requirements, this can be easily extended.'''
alpha = 'abcdefghijklmnopqrstuvwxyz'.upper()
pairs = [''.join((x, y)) for x in alpha \
for y in [''] + [z for z in alpha]]
self.__sscoords = sorted(pairs, key=len)
def __init__(self, oconfig):
'''Create a oopricing output object.'''
tracer.debug("Called.")
StdOutputParams.__init__(self, oconfig)
CreateMakeDependencies.__init__(self)
self.doc_styles = {}
self.__used_vcs_id = None
self.__setup_coord_lookup()
def topic_continuum_sort(self, vcs_commit_ids, topic_sets):
'''Because oopricing1 can only one topic continuum,
the latest (newest) is used.'''
self.__used_vcs_id = vcs_commit_ids[-1]
return [ topic_sets[vcs_commit_ids[-1].get_commit()] ]
def __create_meta(self):
'''Create the meta-information for the document.'''
m = odf.meta.Generator(text="rmtoo")
self.__calcdoc.meta.addElement(m)
m = odf.dc.Title(text="Requirements Pricing")
self.__calcdoc.meta.addElement(m)
m = odf.meta.UserDefined(name="Version",
text=self.__used_vcs_id)
self.__calcdoc.meta.addElement(m)
m = odf.meta.UserDefined(name="Generator", text="rmtoo")
self.__calcdoc.meta.addElement(m)
### Functions handling style
def __create_styles_table_cell(self):
# Bold
s = odf.style.Style(name="tc-bold", family="table-cell")
s.addElement(
odf.style.TextProperties(fontweight="bold", fontsize="12pt"))
self.__calcdoc.automaticstyles.addElement(s)
self.doc_styles["tc-bold"] = s
# Bold with blue background for header
s = odf.style.Style(name="tc-bold-blue", family="table-cell")
s.addElement(
odf.style.TextProperties(fontweight="bold", fontsize="12pt"))
s.addElement(
odf.style.TableCellProperties(backgroundcolor="#99ccff"))
self.__calcdoc.automaticstyles.addElement(s)
self.doc_styles["tc-bold-blue"] = s
# Shrink-to-fit
s = odf.style.Style(name="tc-shrink-to-fit", family="table-cell")
s.addElement(
odf.style.TableCellProperties(shrinktofit="true"))
s.addElement(odf.style.TableCellProperties(cellprotect="none",
printcontent="true"))
self.__calcdoc.automaticstyles.addElement(s)
self.doc_styles["tc-shrink-to-fit"] = s
def __create_styles_table_column(self):
'''The different column style differ only in the columnwidth.'''
colstyles = {
"col-comment": "10in",
"col-days": "0.5in",
"col-dayrate": "0.65in",
"col-compliant": "0.75in",
"col-material": "0.8in",
"col-sum": "0.9in",
"col-ids": "1.2in",
"col-name": "2.25in",
"col-supplier": "0.75in",
}
# The sorted() is done to get always the same XML document -
# which is important for comparison in tests.
for name, size in sorted(colstyles.iteritems()):
s = odf.style.Style(name=name, family="table-column")
s.addElement(
odf.style.TableColumnProperties(columnwidth=size))
self.__calcdoc.automaticstyles.addElement(s)
self.doc_styles[name] = s
def __create_styles_currency(self):
'''Column Style for Euro: only full Euros.'''
# The positive part
s = odf.number.CurrencyStyle(name="cs-euro-positive",
volatile="true")
s.addElement(odf.number.Number(
decimalplaces="0", grouping="true", minintegerdigits="1"))
s.addElement(odf.number.Text(text=" "))
s.addElement(odf.number.CurrencySymbol(
text=u"€", country="DE", language="de"))
self.__calcdoc.styles.addElement(s)
# This is the negative part: there is the decision, which one
# is used.
s = odf.number.CurrencyStyle(name="cs-euro")
s.addElement(odf.number.Text(text="-"))
s.addElement(odf.number.Number(
decimalplaces="0", grouping="true", minintegerdigits="1"))
s.addElement(odf.number.Text(text=" "))
s.addElement(odf.number.CurrencySymbol(
text=u"€", country="DE", language="de"))
s.addElement(odf.style.Map(
applystylename="cs-euro-positive", condition="value()>=0"))
self.__calcdoc.styles.addElement(s)
# This is the one for the read-only modules
s = odf.style.Style(name="col-euro", family="table-cell",
datastylename="cs-euro")
self.__calcdoc.automaticstyles.addElement(s)
self.doc_styles["col-euro"] = s
# And the same for read-write.
s = odf.style.Style(name="col-euro-rw", family="table-cell",
datastylename="cs-euro")
s.addElement(odf.style.TableCellProperties(cellprotect="none",
printcontent="true"))
self.__calcdoc.automaticstyles.addElement(s)
self.doc_styles["col-euro-rw"] = s
def __create_styles_int(self):
'''Number as used for days count.'''
s = odf.number.NumberStyle(name="ns-int")
s.addElement(odf.number.Number(
decimalplaces="0", minintegerdigits="1"))
self.__calcdoc.automaticstyles.addElement(s)
# The version for read-only.
s = odf.style.Style(name="col-int", family="table-cell",
datastylename="ns-int")
self.__calcdoc.automaticstyles.addElement(s)
self.doc_styles["col-int"] = s
# And the same for rw.
s = odf.style.Style(name="col-int-rw", family="table-cell",
datastylename="ns-int")
s.addElement(odf.style.TableCellProperties(cellprotect="none",
printcontent="true"))
self.__calcdoc.automaticstyles.addElement(s)
self.doc_styles["col-int-rw"] = s
def __create_styles(self):
'''There is the need to apply some styles.'''
# There is the need for many different styles.
self.__create_styles_table_cell()
self.__create_styles_table_column()
self.__create_styles_currency()
self.__create_styles_int()
def topic_set_pre(self, topics_set):
'''Document setup and output.
Because for this document a very specific sort order
must be implemented, everything must be done here explicitly -
the executor interface can only partially be used.'''
self.__calcdoc = OpenDocumentSpreadsheet()
self.__create_meta()
self.__create_styles()
def topic_set_post(self, topics_set):
'''Document storage.'''
self.__calcdoc.save(self._output_filename, True)
# Sheet creation functions.
def __create_costs_sheet(self, sreqs):
sheet = odf.table.Table(name="Costs", protected="true")
self.create_form(sheet, sreqs)
self.create_costs_column_styles(sheet)
self.create_costs_header(sheet, sreqs[0])
self.create_costs_content(sheet, sreqs)
self.__calcdoc.spreadsheet.addElement(sheet)
def __create_deps_sheet(self, sreqs):
sheet = odf.table.Table(name="Deps") #, protected="true")
self.create_reqs_ids_row(sheet, sreqs)
# The second row is where all the results will be inserted.
# Therefore put in each one a none.
tr = odf.table.TableRow()
for _ in sreqs:
self.create_text_cell(tr, "none")
sheet.addElement(tr)
# The third row contains the indices of the requirement
# which is chosen as the dependent one.
tr = odf.table.TableRow()
for req in sreqs:
tc = odf.table.TableCell()
if req.get_incoming_cnt() > 0:
# By default, the chosen is the first one.
p = odf.text.P(text=req.get_iter_incoming().next().get_name())
tc.addElement(p)
tr.addElement(tc)
sheet.addElement(tr)
self.create_empty_row(sheet)
# Output all the dependent requirements
self.create_deps_dependent(sheet, sreqs)
self.__calcdoc.spreadsheet.addElement(sheet)
def __create_sums_sheet(self, sreqs):
self.create_one_sums_sheet(self.__calcdoc, sreqs, "SumRate", "L")
self.create_one_sums_sheet(self.__calcdoc, sreqs, "SumMat", "M")
def __create_constants_sheet(self):
sheet = odf.table.Table(name="Constants", protected="true")
# This is the list where the requirement compliance gets it
# values from.
for r in ["none", "partial", "fully"]:
tr = odf.table.TableRow()
tc = odf.table.TableCell()
p = odf.text.P(text=r)
tc.addElement(p)
tr.addElement(tc)
sheet.addElement(tr)
self.__calcdoc.spreadsheet.addElement(sheet)
# This is added to get all the results in one point (sheet)
# which makes it easier to handle the output.
def __create_result_sheet(self, sreqs):
sheet = odf.table.Table(name="Results", protected="true")
i = 0
for req in sreqs:
tr = odf.table.TableRow()
self.create_result_one_req(tr, req, i)
sheet.addElement(tr)
i += 1
self.__calcdoc.spreadsheet.addElement(sheet)
def requirement_set_pre(self, requirement_set):
'''The output of all the content.'''
# Because of a problem with the current OpenOffice versions,
# there is the need to sometimes arrange requirements as rows
# and sometimes as columns:
# It is not possible to define the range of a list input as a
# row: it must be a column.
# The order dictionary holds the number - which can be
# computed in a row or column.
def create_reqs_index(srqes):
sreqs_index = {}
cnt = 0
for req in sreqs:
sreqs_index[req] = cnt
cnt += 1
return sreqs_index
sreqs = topological_sort(requirement_set)
# Create the row / column index of each requirement
self.sreqs_index = create_reqs_index(sreqs)
# Create and save the document
self.__create_costs_sheet(sreqs)
self.__create_deps_sheet(sreqs)
self.__create_sums_sheet(sreqs)
self.__create_constants_sheet()
self.__create_result_sheet(sreqs)
def cmad_topic_continuum_pre(self, _):
'''Write out the one and only dependency to all the requirements.'''
tracer.debug("Called.")
CreateMakeDependencies.write_reqs_dep(self._cmad_file,
self._output_filename)
#################################################################
### 2nd level functions
###
### helper functions
# Create an empty row
@staticmethod
def create_empty_row(sheet):
tr = odf.table.TableRow()
sheet.addElement(tr)
@staticmethod
def create_empty_cell(row):
tc = odf.table.TableCell()
row.addElement(tc)
@staticmethod
def create_empty_currency_cell(row):
tc = odf.table.TableCell(
valuetype="currency", currency="EUR",
stylename="col-euro-rw")
tc.addElement(odf.text.P())
row.addElement(tc)
@staticmethod
def create_empty_currency_cell_ro(row):
tc = odf.table.TableCell(
valuetype="currency", currency="EUR",
stylename="col-euro")
tc.addElement(odf.text.P())
row.addElement(tc)
@staticmethod
def create_empty_int_cell(row):
tc = odf.table.TableCell(
valuetype="float", value="0",
stylename="col-int-rw")
tc.addElement(odf.text.P())
row.addElement(tc)
# Create the first row in the deps or sums sheet: all the ids
@staticmethod
def create_reqs_ids_row(sheet, sreqs):
tr = odf.table.TableRow()
for req in sreqs:
tc = odf.table.TableCell()
p = odf.text.P(text=req.get_name())
tc.addElement(p)
tr.addElement(tc)
sheet.addElement(tr)
# Creates a text cell with the given text. Optional a style can be
# specified.
@staticmethod
def create_text_cell(table_row, text, style=None):
if style != None:
tc = odf.table.TableCell(stylename=style)
else:
tc = odf.table.TableCell()
if text != None:
p = odf.text.P(text=text)
tc.addElement(p)
table_row.addElement(tc)
### Functions handling costs
def create_costs_column_styles(self, sheet):
# 1 Colum: Ids
tc = odf.table.TableColumn(stylename=self.doc_styles["col-ids"])
sheet.addElement(tc)
# 2 Colum: Name
tc = odf.table.TableColumn(stylename=self.doc_styles["col-name"])
sheet.addElement(tc)
# 3 Colum: Compliant
tc = odf.table.TableColumn(stylename=self.doc_styles["col-compliant"])
sheet.addElement(tc)
# 4 Colum: Costs-dayrate
tc = odf.table.TableColumn(
stylename=self.doc_styles["col-dayrate"],
defaultcellstylename=self.doc_styles["col-euro"])
sheet.addElement(tc)
# 5 Colum: Costs-days
tc = odf.table.TableColumn(
stylename=self.doc_styles["col-days"],
defaultcellstylename=self.doc_styles["col-int"])
sheet.addElement(tc)
# 6 Colum: Costs-material
tc = odf.table.TableColumn(
stylename=self.doc_styles["col-material"],
defaultcellstylename=self.doc_styles["col-euro"])
sheet.addElement(tc)
# 7 Colum: Costs-sum
tc = odf.table.TableColumn(
stylename=self.doc_styles["col-sum"],
defaultcellstylename=self.doc_styles["col-euro"])
sheet.addElement(tc)
# 8 Colum: Dependent from
tc = odf.table.TableColumn(stylename=self.doc_styles["col-ids"])
sheet.addElement(tc)
# 9-14 Sum columns
for _ in ["dep-rate", "dep-mat", "dep-sum",
"ovl-rate", "ovl-mat", "ovl-sum"]:
tc = odf.table.TableColumn(
stylename=self.doc_styles["col-sum"],
defaultcellstylename=self.doc_styles["col-euro"])
sheet.addElement(tc)
# 15 Supplier
tc = odf.table.TableColumn(stylename=self.doc_styles["col-supplier"])
sheet.addElement(tc)
# 16 Comment
tc = odf.table.TableColumn(stylename=self.doc_styles["col-comment"])
sheet.addElement(tc)
def create_costs_header(self, sheet, req):
# First is empty
self.create_empty_row(sheet)
# Second holds only the Overall sum
tr = odf.table.TableRow()
self.create_text_cell(tr, req.get_name(),
self.doc_styles["tc-bold"])
sheet.addElement(tr)
# Followed by an additionally empty line
self.create_empty_row(sheet)
# Table header line 1
tr = odf.table.TableRow()
for h in ["Id", "Name", "Compliant", "Costs for requirement",
None, None, None, "Dependent from",
"Costs of dependent", None, None,
"Overall sum", None, None, "Supplier", "Comment"]:
self.create_text_cell(tr, h, self.doc_styles["tc-bold-blue"])
sheet.addElement(tr)
# Table header line 2
tr = odf.table.TableRow()
for h in [None, None, None, "dayrate",
"#days", "material", "sum", None,
"rate", "material", "sum",
"rate", "material", "sum", None, None]:
self.create_text_cell(tr, h, self.doc_styles["tc-bold-blue"])
sheet.addElement(tr)
def create_costs_content(self, sheet, sreqs):
i = 0
for req in sreqs:
tr = odf.table.TableRow()
self.create_costs_content_req(tr, req, i)
sheet.addElement(tr)
i += 1
def create_costs_content_req(self, tr, dnreq, i):
req = dnreq.get_requirement()
choi = i + DEPS_HEADER_LEN
# First cell is the id
self.create_text_cell(tr, dnreq.get_name())
# Second cell is the name
self.create_text_cell(tr, req.get_value("Name").get_content())
# Third is the compliant
tc = odf.table.TableCell()
dc = odf.draw.Control(control="lbcompliant%s" % dnreq.get_name(),
zindex="0",
x="0.0in",
y="0.0in",
endcelladdress="Costs.C%d" % (choi + 1),
endx="0.75in",
endy="0.0in")
tc.addElement(dc)
tr.addElement(tc)
# Three empty columns for costs
self.create_empty_currency_cell(tr)
self.create_empty_int_cell(tr)
self.create_empty_currency_cell(tr)
# Sum / factor of before ones
tc = odf.table.TableCell(
valuetype="currency", currency="EUR",
formula="oooc:=[.D%d]*[.E%d]+[.F%d]" % (choi, choi, choi))
tr.addElement(tc)
# Dependent on Chooser
tc = odf.table.TableCell()
# Do not do this for first cell.
if dnreq.get_incoming_cnt() > 0:
dc = odf.draw.Control(control="lbdependentfrom%s" % dnreq.get_name(),
zindex="0",
x="0.0in",
y="0.0in",
endcelladdress="Costs.H%d" % (choi + 1),
endx="1.2in",
endy="0.0in")
tc.addElement(dc)
tr.addElement(tc)
# dependet rate and material
# Do not do this for first cell.
for sname in ["SumRate", "SumMat"]:
if dnreq.get_outgoing_cnt() > 0:
tc = odf.table.TableCell(
valuetype="currency", currency="EUR",
formula="oooc:=SUM([%s.%s2:%s.%s%d])" \
% (sname, self.__sscoords[i], sname, self.__sscoords[i],
(1 + dnreq.get_outgoing_cnt())))
tr.addElement(tc)
else:
self.create_empty_currency_cell_ro(tr)
# sum of dependent
tc = odf.table.TableCell(
valuetype="currency", currency="EUR",
formula="oooc:=[.I%d]+[.J%d]" % (choi, choi))
tr.addElement(tc)
# Overall rate
tc = odf.table.TableCell(
valuetype="currency", currency="EUR",
formula="oooc:=[.D%d]*[.E%d]+[.I%d]" % (choi, choi, choi))
tr.addElement(tc)
# Overall material
tc = odf.table.TableCell(
valuetype="currency", currency="EUR",
formula="oooc:=[.F%d]+[.J%d]" % (choi, choi))
tr.addElement(tc)
# Overall sum
tc = odf.table.TableCell(
valuetype="currency", currency="EUR",
formula="oooc:=[.L%d]+[.M%d]" % (choi, choi))
tr.addElement(tc)
# Supplier
tc = odf.table.TableCell(
valuetype="string", stylename=self.doc_styles["tc-shrink-to-fit"])
tr.addElement(tc)
# Comment
tc = odf.table.TableCell(
valuetype="string", stylename=self.doc_styles["tc-shrink-to-fit"])
tr.addElement(tc)
### Functions handling deps
def create_deps_dependent(self, sheet, sreqs):
# The number of the following rows depend on the maximum
# number of incoming requirements.
# This flags if there is something found with the current
# index.
i = 0
while True:
tr = odf.table.TableRow()
index_used = False
for req in sreqs:
if req.get_incoming_cnt() > i:
tc = odf.table.TableCell()
# ToDo: Experimental
## p = odf.text.P(text=req.incoming[i].name)
p = odf.text.P(text=req.get_iter_incoming().next().get_name())
tc.addElement(p)
tr.addElement(tc)
index_used = True
else:
tc = odf.table.TableCell()
tr.addElement(tc)
sheet.addElement(tr)
if not index_used:
break
i += 1
### Functions handling sums
# Create one sum sheet
def create_one_sums_sheet(self, calcdoc, sreqs, name, colname):
sheet = odf.table.Table(name=name, protected="true")
self.create_reqs_ids_row(sheet, sreqs)
i = 0
while True:
tr = odf.table.TableRow()
index_used = False
for req in sreqs:
if req.get_outgoing_cnt() > i:
# This is somewhat complicated:
# If on the Costs sheet one direction is chosen,
# it is written to the deps sheet (row 3).
# If this row contains the name of the current
# requirment, it is chosen to be dependent and the
# overall costs of that requirement must go to the
# local list - which then is again summed over on
# the cost sheet.
# ToDo: WHAT TO DO????????
# tc = odf.table.TableCell(
# valuetype="currency", currency="EUR",
# formula='oooc:=IF([Deps.%s3]="%s";[Costs.%s%d];0)' %
# (self.__sscoords[self.sreqs_index[req.outgoing[i]]],
# req.name, colname,
# self.sreqs_index[req.outgoing[i]] + DEPS_HEADER_LEN))
tc = odf.table.TableCell(
valuetype="currency", currency="EUR",
formula='oooc:=IF([Deps.%s3]="%s";[Costs.%s%d];0)' %
(self.__sscoords[self.sreqs_index[req.get_iter_outgoing().next()]],
req.get_name(), colname,
self.sreqs_index[req.get_iter_outgoing().next()] + DEPS_HEADER_LEN))
tr.addElement(tc)
index_used = True
else:
tc = odf.table.TableCell()
tr.addElement(tc)
sheet.addElement(tr)
if not index_used:
break
i += 1
calcdoc.spreadsheet.addElement(sheet)
### Functions handling forms
def create_form(self, calcdoc, sreqs):
forms = odf.office.Forms(
applydesignmode="false",
automaticfocus="false")
form = odf.form.Form(
applyfilter="true",
commandtype="table",
controlimplementation="ooo:com.sun.star.form.component.Form",
name="Standard",
targetframe="",
href="")
# Listboxes for compliant
i = 0
for req in sreqs:
lb = odf.form.Listbox(
id="lbcompliant%s" % req.get_name(),
boundcolumn="1",
dropdown="yes",
controlimplementation="ooo:com.sun.star.form.component.ListBox",
linkedcell="Deps.%s2" % self.__sscoords[i],
listlinkagetype="selection",
name="ListBox Compliant %s" % req.get_name(),
size="3",
sourcecellrange="Constants.A1:Constants.A3"
)
lbproperties = odf.form.Properties()
lbprop = odf.form.Property(
propertyname="DefaultControl",
stringvalue="com.sun.star.form.control.ListBox",
valuetype="string")
lbproperties.addElement(lbprop)
# Default selection
lstprop = odf.form.ListProperty(
propertyname="DefaultSelection",
valuetype="float")
defaultval = odf.form.ListValue(stringvalue='0')
lstprop.addElement(defaultval)
lbproperties.addElement(lstprop)
lb.addElement(lbproperties)
form.addElement(lb)
i += 1
# Listboxes for dependent from
i = 0
for req in sreqs:
# When there is only one entry in the list, there is no
# need to have a dropdown list.
ddown = "yes"
if req.get_incoming_cnt() <= 1:
ddown = "no"
lb = odf.form.Listbox(
id="lbdependentfrom%s" % req.get_name(),
boundcolumn="1",
dropdown="yes",
controlimplementation="ooo:com.sun.star.form.component.ListBox",
linkedcell="Deps.%s3" % self.__sscoords[i],
listlinkagetype="selection",
name="ListBox Dependet From %s" % req.get_name(),
size="3",
sourcecellrange="Deps.%s5:Deps.%s%d" % (
self.__sscoords[i], self.__sscoords[i], req.get_incoming_cnt() + 4)
)
lbproperties = odf.form.Properties()
lbprop = odf.form.Property(
propertyname="DefaultControl",
stringvalue="com.sun.star.form.control.ListBox",
valuetype="string")
lbproperties.addElement(lbprop)
# Default selection
lstprop = odf.form.ListProperty(
propertyname="DefaultSelection",
valuetype="float")
defaultval = odf.form.ListValue(stringvalue='0')
lstprop.addElement(defaultval)
lbproperties.addElement(lstprop)
# Read only
# When there is only one dependent requirement, it makes
# no sense to have something which can be changed.
# Therefore this should be readonly then.
if req.get_incoming_cnt() <= 1:
lstprop = odf.form.Property(
propertyname="ReadOnly",
valuetype="boolean",
booleanvalue="true")
lbproperties.addElement(lstprop)
lb.addElement(lbproperties)
form.addElement(lb)
i += 1
forms.addElement(form)
calcdoc.addElement(forms)
### Functions handling result sheet
def create_result_one_req(self, tr, req, i):
# 1 Id
self.create_text_cell(tr, req.get_name())
# 2 Compliance
tc = odf.table.TableCell(
valuetype="string",
formula="oooc:=[Deps.%s2]" % self.__sscoords[i])
tr.addElement(tc)
# Prices
for r in ["D", "E", "F"]:
tc = odf.table.TableCell(
valuetype="string",
formula="oooc:=[Costs.%s%d]" % (r, i + DEPS_HEADER_LEN))
tr.addElement(tc)
# Dependent from
tc = odf.table.TableCell(
valuetype="string",
formula="oooc:=[Deps.%s3]" % self.__sscoords[i])
tr.addElement(tc)
# Supplier
tc = odf.table.TableCell(
valuetype="string",
formula="oooc:=[Costs.O%d]" % (i + DEPS_HEADER_LEN))
tr.addElement(tc)
# Comment
tc = odf.table.TableCell(
valuetype="string",
formula="oooc:=[Costs.P%d]" % (i + DEPS_HEADER_LEN))
tr.addElement(tc)
if f_type == 'many2one':
d = d and d[1] or ''
elif f_type == 'many2many':
d = ','.join(map(str, d))
elif f_type == 'one2many':
d = ','.join(map(str, d))
if isinstance(d, int):
tc = TableCell(valuetype="int", value=d)
elif isinstance(d, float):
tc = TableCell(valuetype="float", value=d)
elif isinstance(d, bool):
tc = TableCell(valuetype="bool", value=d)
else:
tc = TableCell(valuetype='string')
tr.addElement(tc)
if isinstance(d, unicode):
p = P(stylename=tablecontents, text=d)
else:
p = P(stylename=tablecontents, text=unicode(str(d), 'utf-8'))
tc.addElement(p)
cpt += 1
textdoc.spreadsheet.addElement(table)
textdoc.save(opts.filename)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
def save(self, filename, i_max = None, j_max = None):
''' save table in ods format '''
if not i_max: i_max = self.table.i_max
if not j_max: j_max = self.table.j_max
# update cells text
self.table.updateTable(i_max, j_max)
# create new odf spreadsheet
odfdoc = OpenDocumentSpreadsheet()
# set direction style
rtl = Style(name = "dir", family = "table")
if self.table.direction == 'rtl':
rtl.addElement(TableProperties(writingmode="rl-tb"))
odfdoc.automaticstyles.addElement(rtl)
# create the table
table = Table(name = "sheet 1", stylename = 'dir')
# default style
ts = Style(name = "ts", family = "table-cell")
ts.addElement(TextProperties(fontfamily = SodsCell().font_family, fontsize = SodsCell().font_size))
odfdoc.styles.addElement(ts)
# create columns
for j in range(1, j_max):
colname = "col" + str(j)
c = self.table.getCellAt(0, j)
width = c.column_width
cs = Style(name = colname, family = "table-column")
cs.addElement(TableColumnProperties(columnwidth = width, breakbefore = "auto"))
odfdoc.automaticstyles.addElement(cs)
table.addElement(TableColumn(stylename = colname, defaultcellstylename = "ts"))
# make sure values are up to date
# loop and update the cells value
for i in range(1, i_max):
# create new ods row
tr = TableRow()
table.addElement(tr)
# create default data styles for dates and numbers
ncs = NumberStyle(name="ncs")
ncs.addElement(Number(decimalplaces="2", minintegerdigits="1", grouping="true"))
odfdoc.styles.addElement(ncs)
ncs2 = NumberStyle(name="ncs2")
ncs2.addElement(Number(decimalplaces="0", minintegerdigits="1", grouping="false"))
odfdoc.styles.addElement(ncs2)
dcs = DateStyle(name="dcs")
dcs.addElement(Year(style='long'))
dcs.addElement(Text(text = u'-'))
dcs.addElement(Month(style='long'))
dcs.addElement(Text(text = u'-'))
dcs.addElement(Day(style='long'))
odfdoc.styles.addElement(dcs)
for j in range(1, j_max):
# update the cell text and condition
cell = self.table.encodeColName(j) + str(i)
c = self.table.getCellAt(i, j)
# chose datastylename
if c.value_type == 'date':
datastylename = "dcs"
else:
if c.format == "":
datastylename = "ncs2"
if c.format == "#,##0.00":
datastylename = "ncs"
# get cell style id
if (c.condition):
style_id = (datastylename + c.color + c.font_size + c.font_family +
c.background_color + c.border_top + c.border_bottom +
c.border_left + c.border_right +
c.condition_color + c.condition_background_color)
else:
style_id = (datastylename + c.color + c.font_size + c.font_family +
c.background_color + c.border_top + c.border_bottom +
c.border_left + c.border_right)
# set ods style
style_name = self.getStyle(c, cell, datastylename, style_id, odfdoc)
# create new ods cell
if (c.formula and c.formula[0] == '=' and c.formula[:4] != '=uni'):
if self.table.isFloat(c.value):
tc = TableCell(valuetype = c.value_type,
formula = c.formula, value = float(c.value), stylename = style_name)
else:
tc = TableCell(valuetype = c.value_type,
formula = c.formula,
value = 0, stylename = style_name)
elif (c.value_type == 'date'):
tc = TableCell(valuetype = c.value_type,
datevalue = c.date_value, stylename = style_name)
elif (c.value_type == 'float') and self.table.isFloat(c.value):
tc = TableCell(valuetype = c.value_type,
value = float(c.value), stylename = style_name)
else:
tc = TableCell(valuetype = 'string', stylename = style_name)
# set ods text
tc.addElement(P(text = unicode(escape(c.text), 'utf-8')))
tr.addElement(tc)
odfdoc.spreadsheet.addElement(table)
odfdoc.save(filename)
def create_ods(filename):
doc = OpenDocumentSpreadsheet()
# doc.spreadsheet.addElement(table)
# doc.save(filename, True) # add "ods" as suffix
doc.save(filename) # not add "ods" as suffix
# remove the .ods suffix if any, as ODF will ad one
m = re.match(r"^(.*)\.ods$", ofilename.strip())
if m:
ofilename = m.group(1)
doc = OpenDocumentSpreadsheet()
# Start the table, and describe the columns
table = Table(name="Password")
f = open(ifilename, "r", encoding="latin-1")
for line in f:
rec = line.strip().split(";")
tr = TableRow()
table.addElement(tr)
for val in rec:
m = re.match(r'"(.*)"', val)
if m:
val = m.group(1)
isnumber, value = parseFloat(val)
if isnumber:
tc = TableCell(value=value, valuetype="float")
else:
tc = TableCell()
tr.addElement(tc)
p = P(text=val)
tc.addElement(p)
doc.spreadsheet.addElement(table)
doc.save(ofilename, True)
# Create automatic styles for the column widths.
# We want two different widths, one in inches, the other one in metric.
# ODF Standard section 15.9.1
widthshort = Style(name="Wshort", family="table-column")
widthshort.addElement(TableColumnProperties(columnwidth="1.7cm"))
textdoc.automaticstyles.addElement(widthshort)
widthwide = Style(name="Wwide", family="table-column")
widthwide.addElement(TableColumnProperties(columnwidth="1.5in"))
textdoc.automaticstyles.addElement(widthwide)
# Start the table, and describe the columns
table = Table(name="Password")
table.addElement(TableColumn(numbercolumnsrepeated=4,stylename=widthshort))
table.addElement(TableColumn(numbercolumnsrepeated=3,stylename=widthwide))
f = open('/etc/passwd')
for line in f:
rec = line.strip().split(":")
tr = TableRow()
table.addElement(tr)
for val in rec:
tc = TableCell()
tr.addElement(tc)
p = P(stylename=tablecontents,text=unicode(val,PWENC))
tc.addElement(p)
textdoc.spreadsheet.addElement(table)
textdoc.save("passwd.ods")
# ODF Standard section 15.9.1
widthshort = Style(name="Wshort", family="table-column")
widthshort.addElement(TableColumnProperties(columnwidth="1.7cm"))
doc.automaticstyles.addElement(widthshort)
widthwide = Style(name="Wwide", family="table-column")
widthwide.addElement(TableColumnProperties(columnwidth="1.5in"))
doc.automaticstyles.addElement(widthwide)
# chenyang20140702-start
# create style for big title
bigtitle = Style(name="Large number", family="table-cell")
bigtitle.addElement(TextProperties(fontfamily="WenQuanYi Micro Hei", fontsize="20pt", fontsizeasian="50pt"))
bigtitle.addElement(TableColumnProperties(columnwidth="17cm"))
doc.styles.addElement(bigtitle)
# chenyang20140702-end
# Start the table, and describe the columns
table = Table(name="big_title")
#table.addElement(TableColumn(numbercolumnsrepeated=4,stylename=widthshort))
#table.addElement(TableColumn(numbercolumnsrepeated=3,stylename=widthwide))
# glue start
tr = TableRow()
table.addElement(tr)
cell(tr, "a部b门主c管", bigtitle)
# glue end
doc.spreadsheet.addElement(table)
doc.save("big_title", True)
ns2.addElement(Number(decimalplaces="2", minintegerdigits="1", grouping="true"))
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)
textdoc.save("currency.ods")
table.addElement(
TableColumn(stylename=widewidth, defaultcellstylename="ce1"))
for row in xrange(1, MSIZE + 1):
# Create a row (same as <tr> in HTML)
tr = TableRow()
table.addElement(tr)
for col in xrange(1, MSIZE + 1):
if (col == row):
cell = TableCell(valuetype="string", stylename="cs1")
cell.addElement(P(text=u"X")) # The current displayed value
elif (col < row):
cell = TableCell(formula=u"=%s%s" % (lit(row), col),
valuetype="string",
stylename="cs2")
else:
cell = TableCell(valuetype="string", stylename="cs3")
cell.addElement(P(text=u"")) # The current displayed value
tr.addElement(cell)
tr = TableRow()
table.addElement(tr)
for col in xrange(1, MSIZE + 1):
cell = TableCell(valuetype="string", stylename="cs4")
cell.addElement(P(text=u"%s" % (col))) # The current displayed value
tr.addElement(cell)
textdoc.spreadsheet.addElement(table)
textdoc.save("keymatrix.ods")
widthwide = Style(name="Wwide", family="table-column")
widthwide.addElement(TableColumnProperties(columnwidth="1.5in"))
textdoc.automaticstyles.addElement(widthwide)
# Start the table, and describe the columns
table = Table(name=sqltable)
#table.addElement(TableColumn(numbercolumnsrepeated=4,stylename=widthshort))
#table.addElement(TableColumn(numbercolumnsrepeated=3,stylename=widthwide))
cx = sqlite.connect(sqldb)
cu = cx.cursor()
cu.execute("select * from %s" % sqltable)
for row in cu.fetchall():
tr = TableRow()
table.addElement(tr)
for val in row:
tc = TableCell()
tr.addElement(tc)
if type(val) == type(''):
textval = unicode(val, 'utf-8')
else:
textval = str(val)
p = P(stylename=tablecontents, text=textval)
tc.addElement(p)
cx.close()
textdoc.spreadsheet.addElement(table)
textdoc.save(sqltable, True)
class _ODSWriter(ExcelWriter):
engine = "odf"
supported_extensions = (".ods",)
def __init__(
self, path: str, engine: Optional[str] = None, mode: str = "w", **engine_kwargs
):
from odf.opendocument import OpenDocumentSpreadsheet
engine_kwargs["engine"] = engine
if mode == "a":
raise ValueError("Append mode is not supported with odf!")
super().__init__(path, mode=mode, **engine_kwargs)
self.book = OpenDocumentSpreadsheet()
self._style_dict: Dict[str, str] = {}
def save(self) -> None:
"""
Save workbook to disk.
"""
for sheet in self.sheets.values():
self.book.spreadsheet.addElement(sheet)
self.book.save(self.path)
def write_cells(
self,
cells: List[ExcelCell],
sheet_name: Optional[str] = None,
startrow: int = 0,
startcol: int = 0,
freeze_panes: Optional[Tuple[int, int]] = 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.sheets[sheet_name] = wks
if validate_freeze_panes(freeze_panes):
assert freeze_panes is not None
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
for row_nr in range(max(rows.keys()) + 1):
wks.addElement(rows[row_nr])
def _make_table_cell_attributes(self, cell) -> Dict[str, Union[int, str]]:
"""Convert cell attributes to OpenDocument attributes
Parameters
----------
cell : ExcelCell
Spreadsheet cell data
Returns
-------
attributes : Dict[str, Union[int, str]]
Dictionary with attributes and attribute values
"""
attributes: Dict[str, Union[int, str]] = {}
style_name = self._process_style(cell.style)
if style_name is not None:
attributes["stylename"] = style_name
if cell.mergestart is not None and cell.mergeend is not None:
attributes["numberrowsspanned"] = max(1, cell.mergestart)
attributes["numbercolumnsspanned"] = cell.mergeend
return attributes
def _make_table_cell(self, cell) -> Tuple[str, Any]:
"""Convert cell data to an OpenDocument spreadsheet cell
Parameters
----------
cell : ExcelCell
Spreadsheet cell data
Returns
-------
pvalue, cell : Tuple[str, TableCell]
Display value, Cell value
"""
from odf.table import TableCell
attributes = self._make_table_cell_attributes(cell)
val, fmt = self._value_with_fmt(cell.val)
pvalue = value = val
if isinstance(val, bool):
value = str(val).lower()
pvalue = str(val).upper()
if isinstance(val, datetime.datetime):
value = val.isoformat()
pvalue = val.strftime("%c")
return (
pvalue,
TableCell(valuetype="date", datevalue=value, attributes=attributes),
)
elif isinstance(val, datetime.date):
value = val.strftime("%Y-%m-%d")
pvalue = val.strftime("%x")
return (
pvalue,
TableCell(valuetype="date", datevalue=value, attributes=attributes),
)
else:
class_to_cell_type = {
str: "string",
int: "float",
float: "float",
bool: "boolean",
}
return (
pvalue,
TableCell(
valuetype=class_to_cell_type[type(val)],
value=value,
attributes=attributes,
),
)
def _process_style(self, style: Dict[str, Any]) -> str:
"""Convert a style dictionary to a OpenDocument style sheet
Parameters
----------
style : Dict
Style dictionary
Returns
-------
style_key : str
Unique style key for for later reference in sheet
"""
from odf.style import (
ParagraphProperties,
Style,
TableCellProperties,
TextProperties,
)
if style is None:
return None
style_key = json.dumps(style)
if style_key in self._style_dict:
return self._style_dict[style_key]
name = f"pd{len(self._style_dict)+1}"
self._style_dict[style_key] = name
odf_style = Style(name=name, family="table-cell")
if "font" in style:
font = style["font"]
if font.get("bold", False):
odf_style.addElement(TextProperties(fontweight="bold"))
if "borders" in style:
borders = style["borders"]
for side, thickness in borders.items():
thickness_translation = {"thin": "0.75pt solid #000000"}
odf_style.addElement(
TableCellProperties(
attributes={f"border{side}": thickness_translation[thickness]}
)
)
if "alignment" in style:
alignment = style["alignment"]
horizontal = alignment.get("horizontal")
if horizontal:
odf_style.addElement(ParagraphProperties(textalign=horizontal))
vertical = alignment.get("vertical")
if vertical:
odf_style.addElement(TableCellProperties(verticalalign=vertical))
self.book.styles.addElement(odf_style)
return name
def _create_freeze_panes(
self, sheet_name: str, freeze_panes: Tuple[int, int]
) -> None:
"""
Create freeze panes in the sheet.
Parameters
----------
sheet_name : str
Name of the spreadsheet
freeze_panes : tuple of (int, int)
Freeze pane location x and y
"""
from odf.config import (
ConfigItem,
ConfigItemMapEntry,
ConfigItemMapIndexed,
ConfigItemMapNamed,
ConfigItemSet,
)
config_item_set = ConfigItemSet(name="ooo:view-settings")
self.book.settings.addElement(config_item_set)
config_item_map_indexed = ConfigItemMapIndexed(name="Views")
config_item_set.addElement(config_item_map_indexed)
config_item_map_entry = ConfigItemMapEntry()
config_item_map_indexed.addElement(config_item_map_entry)
config_item_map_named = ConfigItemMapNamed(name="Tables")
config_item_map_entry.addElement(config_item_map_named)
config_item_map_entry = ConfigItemMapEntry(name=sheet_name)
config_item_map_named.addElement(config_item_map_entry)
config_item_map_entry.addElement(
ConfigItem(name="HorizontalSplitMode", type="short", text="2")
)
config_item_map_entry.addElement(
ConfigItem(name="VerticalSplitMode", type="short", text="2")
)
config_item_map_entry.addElement(
ConfigItem(
name="HorizontalSplitPosition", type="int", text=str(freeze_panes[0])
)
)
config_item_map_entry.addElement(
ConfigItem(
name="VerticalSplitPosition", type="int", text=str(freeze_panes[1])
)
)
config_item_map_entry.addElement(
ConfigItem(name="PositionRight", type="int", text=str(freeze_panes[0]))
)
config_item_map_entry.addElement(
ConfigItem(name="PositionBottom", type="int", text=str(freeze_panes[1]))
)
class Save_to_ods:
def __init__(self):
pass
def make_style(self, tablename=date):
#self.doc = load("themplate.ods")
self.doc = OpenDocumentSpreadsheet()
# Create a style for the table content. One we can modify
# later in the word processor.
self.font = FontFace( name="Times New Roman", fontadornments="Normal", fontfamilygeneric="roman", fontpitch="variable" )
self.doc.fontfacedecls.addElement( self.font )
self.root_style = Style(name="rootstyle", family="table-cell")
self.root_style.addElement(
TableCellProperties(
wrapoption="wrap",
verticalalign="middle",
padding="0.049cm",
) )
#self.root_style.addElement( TableRowProperties(breakbefore="auto", useoptimalrowheight="true",rowheight="3cm", ) )
#self.root_style.addElement(ParagraphProperties(numberlines="false", linenumber="0",))# marginleft="0.4cm"))
self.root_style.addElement( TextProperties( fontname="Times New Roman", fontnameasian="Times New Roman", fontsize="10pt"))
self.doc.styles.addElement( self.root_style )
page = PageLayout( name="page" )
self.doc.automaticstyles.addElement( page )
page.addElement( PageLayoutProperties( margintop="0.499cm", marginbottom="0.499cm", marginleft="2cm", marginright="0.499cm", shadow="none", backgroundcolor="transparent", tablecentering="horizontal", writingmode="lr-tb") )
self.head = Style(name="head", family="table-cell", parentstylename="rootstyle")
self.head.addElement( TextProperties(fontweight="bold", fontweightasian="bold", fontsize="12pt"))
self.doc.styles.addElement(self.head)
self.tablehead = Style(name="tablehead", family="table-cell", parentstylename="rootstyle")
self.tablehead.addElement( ParagraphProperties(numberlines="false", linenumber="0", textalign="center"))
self.tablehead.addElement( TableCellProperties( border="0.004cm solid #000000", padding="0.199cm", ) )
self.tablehead.addElement( TextProperties(fontweight="bold", fontweightasian="bold", fontsize="12pt"))
self.doc.styles.addElement(self.tablehead)
self.tablecontents = Style(name="content", family="table-cell", parentstylename="rootstyle")
self.tablecontents.addElement(
TableCellProperties(
border="0.004cm solid #000000",
wrapoption="wrap",
verticalalign="middle",
) )
self.doc.styles.addElement(self.tablecontents)
self.tablemanuf = Style(name="manuf", family="table-cell", parentstylename="rootstyle")
self.tablemanuf.addElement(
TableCellProperties(
border="0.013cm solid #000000",
backgroundcolor="#CCCCCC",
) )
self.tablemanuf.addElement(ParagraphProperties( textalign="center" ))
self.tablemanuf.addElement( TextProperties(fontweight="bold", fontweightasian="bold", fontsize="14pt" ))
self.doc.styles.addElement(self.tablemanuf)
# Create automatic styles for the column widths.
# We want two different widths, one in inches, the other one in metric.
# ODF Standard section 15.9.1
widthname = Style(name="Wname", family="table-column")
widthname.addElement(TableColumnProperties(columnwidth="5 cm"))
self.doc.automaticstyles.addElement(widthname )
widthdesc = Style(name="Wdesc", family="table-column")
widthdesc.addElement(TableColumnProperties(columnwidth="11 cm",useoptimalcolumnwidth
="1"))
self.doc.automaticstyles.addElement( widthdesc )
widthcell = Style(name="Wcell", family="table-column")
widthcell.addElement(TableColumnProperties(columnwidth="2.3 cm"))
widthcell.addElement(ParagraphProperties(numberlines="false", linenumber="0", textalign="end"))
self.doc.automaticstyles.addElement(widthcell)
#>> Start the table, and describe the columns
self.table = Table(name= tablename )
self.table.addElement(TableColumn(numbercolumnsrepeated=1,stylename=widthname))
self.table.addElement(TableColumn(numbercolumnsrepeated=1,stylename=widthdesc))
self.table.addElement(TableColumn(numbercolumnsrepeated=1,stylename=widthcell))
def add_rows(self, _tuple, stylename):
'''
_tuple example
(
('','',), # 1 row
('','','',), # 2 row
)
'''
for _r in _tuple:
tr = TableRow()
self.table.addElement(tr)
for _c in _r:
tc = TableCell( stylename= stylename )
tr.addElement(tc)
p = P(text = _c )
tc.addElement(p)
def add_spanned_row( self, _tuple, stylename, _count_col_spanned = 3):
tr = TableRow()
self.table.addElement(tr)
for _c in _tuple:
tc = TableCell( stylename= stylename )
tc = TableCell( stylename= stylename, numbercolumnsspanned= _count_col_spanned, numberrowsspanned = 1 )
tr.addElement(tc)
p = P(text = _c )
tc.addElement(p)
tr.addElement( CoveredTableCell() )
def add_row( self, _tuple, stylename):
tr = TableRow()
self.table.addElement(tr)
for _c in _tuple:
tc = TableCell( stylename= stylename )
tr.addElement(tc)
p = P(text = _c )
tc.addElement(p)
def add_cell( self, _cell, _table_row, stylename):
tc = TableCell( stylename= stylename )
_table_row.addElement(tc)
p = P(text = _cell )
tc.addElement(p)
def generate_ods(self, path="/home/apkawa/work/test_desu", group=False):
self.make_style( tablename = self.category.name )
self.add_spanned_row( (u'OOO "Политехник"',), self.head )
head = (
( u'phone:','+7 (812) 312-42-38'),
( u'','+7 (812) 970-42-93'),
( u'email:','*****@*****.**'),
( u'www:','http://polytechnik.ru'),
('',),
)
self.add_rows( head, self.head )
self.add_row( ( u'Прайс от %s'%date,), self.root_style )
self.add_spanned_row( (self.category.name, ), self.tablemanuf )
self.add_row( ( u'Наименование',u'Описание',u'Цена',), self.tablehead )
manuf = None
type_product = 13
for p in self.price:
if manuf != p.manufacturer_id and p.manufacturer_id != 233:
manuf = p.manufacturer.id
self.add_spanned_row( (p.manufacturer.name,) , self.tablemanuf )
if type_product != p.type_product_id and p.type_product_id != 13:
type_product = p.type_product_id
self.add_spanned_row( ( p.type_product.name,) , self.tablemanuf )
p_desc = p.desc
p_cell = ' %.0f %s'%(p.cell, p.valyuta.desc) if p.cell else ' -'
if p_desc:
self.add_row( ( p.name, p_desc, p_cell ) , self.tablecontents )
elif not p.desc and not p.cell:
p_name = re.sub('(<h4>|</h4>)','',p.name)
self.add_spanned_row( (p_name,), self.tablehead )
else:
tr = TableRow( stylename = self.tablecontents )
self.table.addElement(tr)
p_price = ( p.name, p_cell )
#self.add_cell( pl, tr, self.tablecontents, )#numbercolumnsspanned=2, numberrowsspanned = 1 )
tc = TableCell( stylename= self.tablecontents, numbercolumnsspanned=2, numberrowsspanned = 1 )
tr.addElement(tc)
p = P(text=p_price[0])
tc.addElement(p)
tr.addElement( CoveredTableCell() )
self.add_cell( p_price[1], tr, self.tablecontents )
self.doc.spreadsheet.addElement( self.table )
self.doc.save( path , True)
def read_stdout(self):
print 'name; desc;cell; manuf;pos;type_product;pos;category_id; img_url'
manuf = None
type_product = None
for p in self.price:
if manuf != p.manufacturer_id and p.manufacturer_id != 233:
manuf = p.manufacturer.id
print '"%s";"%s";\n'%(p.manufacturer.name,p.manufacturer.pos if p.manufacturer.pos else '')
if type_product != p.type_product_id and p.type_product_id != 13:
type_product = p.type_product_id
print '"%s";"%s";\n'%(p.type_product.name, p.type_product.pos if p.type_product.pos else '' )
# 0 1 2 3 4 5 6 7 8
#name_pr desc cell manuf pos type_product pos category_id img_flag
print '"%s";"%s";"%s";"%s";"%s";"%s";"%s";"%s";"%s";'%(p.name,
p.desc if p.desc else '',
'%.0f %s'%(p.cell, p.valyuta.desc),
p.manufacturer.name,
p.manufacturer.pos,
p.type_product.name,
p.type_product.pos,
p.category_id,
p.img_url if p.img_url else '')
def connect_base(self, category_id = 202, manufac_name = False):
self.base = []
self.category = Category.objects.get(id= category_id )
if manufac_name and type(manufac_name) == type([]):
self.price = Price.objects.filter(
category = self.category, manufacturer__name__in = manufac_name ).order_by(
'manufacturer__pos','manufacturer', 'type_product__pos','type_product','id' )
elif manufac_name:
self.price = Price.objects.filter(
category = self.category, manufacturer__name = manufac_name ).order_by(
'manufacturer__pos','manufacturer', 'type_product__pos','type_product','id' )
else:
self.price = Price.objects.filter( category = self.category ).order_by( 'manufacturer__pos','manufacturer',
'type_product__pos','type_product','id' )
if not self.price.count():
return False
else:
return True
ParagraphProperties(parent=tablecontents, numberlines='false', linenumber='0')
TextProperties(parent=tablecontents, fontweight='bold')
# Create automatic styles for the column widths.
# We want two different widths, one in inches, the other one in metric.
# ODF Standard section 15.9.1
widthshort = Style(parent=textdoc.automaticstyles,
name='Wshort',
family='table-column')
TableColumnProperties(parent=widthshort, columnwidth='1.7cm')
widthwide = Style(parent=textdoc.automaticstyles,
name='Wwide',
family='table-column')
TableColumnProperties(parent=widthwide, columnwidth='1.5in')
# Start the table, and describe the columns
table = Table(parent=textdoc.spreadsheet, name='Password')
TableColumn(parent=table, numbercolumnsrepeated=4, stylename=widthshort)
TableColumn(parent=table, numbercolumnsrepeated=3, stylename=widthwide)
with open('/etc/passwd') as f:
for line in f:
rec = line.strip().split(':')
tr = TableRow(parent=table)
for val in rec:
tc = TableCell(parent=tr)
p = P(parent=tc, stylename=tablecontents, text=val)
textdoc.save('passwd.ods')
def export_odf_report(filename: str, borrowing_facts: Iterable[Tuple[str, str,
float]]):
# Thanks to https://joinup.ec.europa.eu/svn/odfpy/tags/release-0.9/api-for-odfpy.odt
# for example of this API
doc = OpenDocumentSpreadsheet()
# -------- add styles -----------
vertcell = Style(name="vcell", family="table-cell")
vertcell.addElement(TableCellProperties(rotationangle=90))
# -------- create table ----------
# Start the table, and describe the columns
table = Table(name="Borrowing")
# ------ process some data ---------
scols = set(gfn for bfn, gfn, bo in borrowing_facts)
cols = sorted(scols)
rows = sorted(set(bfn for bfn, gfn, bo in borrowing_facts))
rc: Dict[str, int] = {}
rr: Dict[str, int] = {}
for c, i in zip(cols, itertools.count()):
rc[c] = i
for r, i in zip(rows, itertools.count()):
rr[r] = i
data = [[0.0] * len(cols) for r in rows] # to make different list
for bfn, gfn, bo in borrowing_facts:
dr = rr[bfn]
dc = rc[gfn]
data[dr][dc] = bo
# --------- go! ----------
tr = TableRow()
tc = TableCell()
tc.addElement(P(text=r"Borrower \ Source"))
tr.addElement(tc)
for c in cols:
tc = TableCell(stylename=vertcell)
tc.addElement(P(text=c))
tr.addElement(tc)
table.addElement(tr)
for r, rd in zip(rows, data):
tr = TableRow()
tc = TableCell()
tc.addElement(P(text=r))
tr.addElement(tc)
for cd in rd:
if cd > 0:
tc = TableCell(valuetype='percentage', value=cd)
else:
tc = TableCell()
tr.addElement(tc)
table.addElement(tr)
doc.spreadsheet.addElement(table)
doc.save(filename, False)
# 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)
textdoc.save("currency.ods")
tmpcs = Map(condition="value()>=0", applystylename="positive-AUD")
ns2.addElement(tmpcs)
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="Test")
# Create a column (same as <col> in HTML) Make all cells in column default to currency
table.addElement(TableColumn(stylename=widthwide, defaultcellstylename="ce1"))
# Create a row (same as <tr> in HTML)
tr = TableRow()
table.addElement(tr)
# Create a cell
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
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)
textdoc.save("test.ods")
