def SaveToLibre(filename, grid):
numcols = grid.GetNumberCols()
numrows = grid.GetNumberRows()
book = ezodf.newdoc(doctype="ods", filename=filename)
book.sheets += ezodf.Sheet('Data', size=(numrows + 10, numcols + 10))
book.sheets += ezodf.Sheet('Meta', size=(20, numcols + 10))
datasheet = book.sheets['Data']
metasheet = book.sheets['Meta']
metasheet[(0,0)].set_value("Name")
metasheet[(1,0)].set_value("Alignment")
metasheet[(2,0)].set_value("Label")
metasheet[(3,0)].set_value("Measure")
metasheet[(4,0)].set_value("Variable type")
metasheet[(5,0)].set_value("Decimal places")
metasheet[(6,0)].set_value("Missing values")
for idxx in range(numcols):
for idxy in range(numrows):
val = grid.GetCellValue(idxy, idxx)
datasheet[(idxy + 1, idxx)].set_value(val)
label = grid.GetColLabelValue(idxx)
meta = grid.meta[label]
datasheet[(0, idxx)].set_value(meta['name'])
metasheet[(0, idxx + 1)].set_value(meta['name'])
metasheet[(1, idxx + 1)].set_value(meta['align'])
metasheet[(2, idxx + 1)].set_value(meta['label'])
metasheet[(3, idxx + 1)].set_value(meta['measure'])
metasheet[(4, idxx + 1)].set_value(meta['ivdv'])
metasheet[(5, idxx + 1)].set_value(meta[str('decplaces')])
metasheet[(6, idxx + 1)].set_value(meta['missingvalues'])
book.save()
def export_to_ods(self, filename, editor):
from database.file_formats.exporter.monodi.ods import MonodiOdsConfig
from ezodf import newdoc, Paragraph, Heading, Sheet
ods = newdoc(doctype='ods', filename=filename)
config = MonodiOdsConfig()
sheet = ezodf.Sheet('Tabellenblatt1', size=(2, config.length))
ods.sheets += sheet
for x in config.entries:
sheet[x.cell.get_entry()].set_value(x.value)
sheet[''.join(
[config.dict['Textinitium Editionseinheit'].cell.column,
str(2)])].set_value(self.textinitium)
sheet[''.join([config.dict['Startseite'].cell.column,
str(2)])].set_value(self.start.page_name)
sheet[''.join([config.dict['Startzeile'].cell.column,
str(2)])].set_value(self.start.row)
sheet[''.join([config.dict['Endseite'].cell.column,
str(2)])].set_value(self.end.page_name)
sheet[''.join([config.dict['Endzeile'].cell.column,
str(2)])].set_value(self.end.row)
sheet[''.join([config.dict['Editor'].cell.column,
str(2)])].set_value(str(editor))
sheet[''.join([config.dict['Doc-Id\' (intern)'].cell.column,
str(2)])].set_value(self.monody_id)
sheet[''.join([config.dict['Quellen-ID (intern)'].cell.column,
str(2)])].set_value('Editorenordner')
bytes = ods.tobytes()
return bytes
def get_rib_sheet(glider_2d):
row_num = glider_2d.shape.half_cell_num + 1
sheet_name = "Rib Elements"
sheet = ezodf.Sheet(name=sheet_name, size=(row_num + 1, 1))
elems = glider_2d.elements
for i in range(1, row_num + 1):
sheet[i, 0].set_value(str(i))
column = 1
# holes
for hole in elems["holes"]:
sheet.append_columns(2)
sheet[0, column].set_value("QUERLOCH")
for rib_no in hole["ribs"]:
sheet[rib_no + 1, column].set_value(hole["pos"])
sheet[rib_no + 1, column + 1].set_value(hole["size"])
column += 2
# attachment points
per_rib = [
glider_2d.lineset.get_upper_nodes(rib_no)
for rib_no in range(glider_2d.shape.half_rib_num)
]
max_points = max([len(p) for p in per_rib])
sheet.append_columns(3 * max_points)
for node_no in range(max_points):
sheet[0, column + 3 * node_no].set_value("AHP")
for rib_no, nodes in enumerate(per_rib):
nodes.sort(key=lambda node: node.rib_pos)
for node_no, node in enumerate(nodes):
sheet[rib_no + 1, column + 3 * node_no].set_value(node.name)
sheet[rib_no + 1, column + 3 * node_no + 1].set_value(node.rib_pos)
sheet[rib_no + 1, column + 3 * node_no + 2].set_value(node.force)
column += 3 * max_points
# rigidfoils
rigidfoils = glider_2d.elements.get("rigidfoils", [])
rigidfoils.sort(key=lambda r: r["start"])
for rigidfoil in rigidfoils:
sheet.append_columns(3)
sheet[0, column].set_value("RIGIDFOIL")
for rib_no in rigidfoil["ribs"]:
sheet[rib_no + 1, column].set_value(rigidfoil["start"])
sheet[rib_no + 1, column + 1].set_value(rigidfoil["end"])
sheet[rib_no + 1, column + 2].set_value(rigidfoil["distance"])
column += 3
return sheet
def get_airfoil_sheet(glider_2d):
profiles = glider_2d.profiles
max_length = max(len(p) for p in profiles)
sheet = ezodf.Sheet(name="Airfoils",
size=(max_length + 1, len(profiles) * 2))
for i, profile in enumerate(profiles):
sheet[0, 2 * i].set_value(profile.name or "unnamed")
for j, p in enumerate(profile):
sheet[j + 1, 2 * i].set_value(p[0])
sheet[j + 1, 2 * i + 1].set_value(p[1])
return sheet
def get_specs(glider):
sheet = ezodf.Sheet("Tech Specs", size=(100, 10))
def set_spec(name, value, line):
sheet[line, 0].set_value(name)
sheet[line, 1].set_value(value)
#set_spec("Name", glider.name, 0)
set_spec("Cells", len(glider.cells), 1)
set_spec("Area", glider.area, 2)
set_spec("Area Projected", glider.projected_area, 3)
set_spec("Aspect Ratio", glider.aspect_ratio, 4)
set_spec("Span", glider.span, 5)
return sheet
def get_geom_sheet(glider_2d):
geom_page = ezodf.Sheet(name="geometry",
size=(glider_2d.shape.half_cell_num + 2, 10))
# rib_nos
geom_page[0, 0].set_value("Ribs")
shape = glider_2d.shape.get_half_shape()
geom_page[0, 1].set_value("Chord")
for i, chord in enumerate(shape.chords):
geom_page[i + 1, 1].set_value(chord)
geom_page[0, 2].set_value("Le x (m)")
geom_page[0, 3].set_value("Le y (m)")
for i, p in enumerate(shape.front):
geom_page[i + 1, 2].set_value(p[0])
geom_page[i + 1, 3].set_value(-p[1])
# set arc values
geom_page[0, 4].set_value("Arc")
last_angle = 0
cell_angles = glider_2d.arc.get_cell_angles(glider_2d.shape.rib_x_values)
if glider_2d.shape.has_center_cell:
cell_angles = cell_angles[1:]
for i, angle in enumerate(cell_angles + [cell_angles[-1]]):
this_angle = angle * 180 / math.pi
geom_page[i + 1, 4].set_value(this_angle - last_angle)
last_angle = this_angle
geom_page[0, 5].set_value("AOA")
geom_page[0, 6].set_value("Z-rotation")
geom_page[0, 7].set_value("Y-rotation")
geom_page[0, 8].set_value("profile-merge")
geom_page[0, 9].set_value("ballooning-merge")
aoa_int = glider_2d.aoa.interpolation(num=100)
profile_int = glider_2d.profile_merge_curve.interpolation(num=100)
ballooning_int = glider_2d.ballooning_merge_curve.interpolation(num=100)
for rib_no, x in enumerate(glider_2d.shape.rib_x_values):
geom_page[rib_no + 1, 0].set_value(rib_no + 1)
geom_page[rib_no + 1, 5].set_value(aoa_int(x) * 180 / math.pi)
geom_page[rib_no + 1, 6].set_value(0)
geom_page[rib_no + 1, 7].set_value(0)
geom_page[rib_no + 1, 8].set_value(profile_int(x))
geom_page[rib_no + 1, 9].set_value(ballooning_int(x))
return geom_page
def get_ballooning_sheet(glider_2d):
balloonings = glider_2d.balloonings
row_num = max([
len(b.upper_spline.controlpoints) + len(b.lower_spline.controlpoints)
for b in balloonings
]) + 1
sheet = ezodf.Sheet(name="Balloonings",
size=(row_num, 2 * len(balloonings)))
for ballooning_no, ballooning in enumerate(balloonings):
#sheet.append_columns(2)
sheet[0, 2 * ballooning_no].set_value(
"ballooning_{}".format(ballooning_no))
pts = list(ballooning.upper_spline.controlpoints) + list(
ballooning.lower_spline.controlpoints)
for i, point in enumerate(pts):
sheet[i + 1, 2 * ballooning_no].set_value(point[0])
sheet[i + 1, 2 * ballooning_no + 1].set_value(point[1])
return sheet
def get_data_sheet(glider):
ods_sheet = ezodf.Sheet(name="Data", size=(3, 10))
ods_sheet[0, 0].set_value("Data")
current_row = 1
# lower attachment_points
for pt_no, att_pt in enumerate(
glider.lineset.get_lower_attachment_points()):
ods_sheet.append_rows(3)
for i, axis in enumerate(['X', 'Y', 'Z']):
ods_sheet[current_row + i,
0].set_value("AHP{}{}".format(axis, att_pt.name))
ods_sheet[current_row + i, 1].set_value(att_pt.pos_3D[i])
current_row += 3
ods_sheet[current_row, 0].set_value("SPEED")
ods_sheet[current_row, 1].set_value(glider.speed)
ods_sheet[current_row + 1, 0].set_value("GLIDE")
ods_sheet[current_row + 1, 1].set_value(glider.glide)
return ods_sheet
def get_parametric_sheet(glider):
line_no = 1 + max([
glider.shape.front_curve.numpoints, glider.shape.back_curve.numpoints,
glider.shape.rib_distribution.numpoints, glider.arc.curve.numpoints
])
sheet = ezodf.Sheet(name="Parametric", size=(line_no, 8))
def add_curve(name, curve, column_no):
#sheet.append_columns(2)
sheet[0, column_no].set_value(name)
for i, p in enumerate(curve):
sheet[i + 1, column_no].set_value(p[0])
sheet[i + 1, column_no + 1].set_value(p[1])
add_curve("front", glider.shape.front_curve.controlpoints, 0)
add_curve("back", glider.shape.back_curve.controlpoints, 2)
add_curve("rib_distribution", glider.shape.rib_distribution.controlpoints,
4)
add_curve("arc", glider.arc.curve.controlpoints, 6)
return sheet
def damp_timetable(self, filename):
''' Creates file in .ods format with selected name for timetable keeping. '''
group_names = sorted([g.id for g in self.groups])
week, hours = TimetablePlanner.WEEK, TimetablePlanner.HOURS + ['6th']
time_slots = [(d, h) for d in week for h in hours]
ods = ezodf.newdoc(doctype='ods', filename=filename)
sheet = ezodf.Sheet('Timetable', size=(37, 6))
ods.sheets += sheet
coords = [str(r) + str(c) for r in 'ABCDEF' for c in range(2, 38)]
headers = [c + '1' for c in 'ABCDEF']
for header, name in zip(headers, group_names):
sheet[header].set_value(name)
start, end = 0, 36
for g in sorted(self.groups, key=lambda x: x.id):
for (coord, timeslot) in zip(coords[start:end], time_slots):
if timeslot in g.busy_time:
sheet[coord].set_value(g.busy_time[timeslot][0])
start, end = end, end + 36
ods.save()
def export_documents_to_ods(documents: List[Document], filename, username):
from database.file_formats.exporter.monodi.ods import MonodiOdsConfig
from ezodf import newdoc, Paragraph, Heading, Sheet
import ezodf
ods = newdoc(doctype='ods', filename=filename)
config = MonodiOdsConfig()
sheet = ezodf.Sheet('Tabellenblatt1',
size=(len(documents) + 1, config.length))
ods.sheets += sheet
for x in config.entries:
sheet[x.cell.get_entry()].set_value(x.value)
for doc_ind, doc in enumerate(documents, start=2):
sheet[''.join([
config.dict['Textinitium Editionseinheit'].cell.column,
str(doc_ind)
])].set_value(doc.textinitium)
sheet[''.join(
[config.dict['Startseite'].cell.column,
str(doc_ind)])].set_value(doc.start.page_name)
sheet[''.join(
[config.dict['Startzeile'].cell.column,
str(doc_ind)])].set_value(doc.start.row)
sheet[''.join([config.dict['Endseite'].cell.column,
str(doc_ind)])].set_value(doc.end.page_name)
sheet[''.join([config.dict['Endzeile'].cell.column,
str(doc_ind)])].set_value(doc.end.row)
sheet[''.join([config.dict['Editor'].cell.column,
str(doc_ind)])].set_value(username)
sheet[''.join(
[config.dict['Doc-Id\' (intern)'].cell.column,
str(doc_ind)])].set_value(doc.monody_id)
sheet[''.join(
[config.dict['Quellen-ID (intern)'].cell.column,
str(doc_ind)])].set_value('Editorenordner')
bytes = ods.tobytes()
return bytes
def __init__(self, ods_book, ods_sheet, sheet_name, **keywords):
self.ods_book = ods_book
self.ods_sheet = ezodf.Sheet(sheet_name)
self.current_row = 0
def set_sheet_name(self, name):
self.native_sheet = ezodf.Sheet(name)
self.current_row = 0
#!/usr/bin/env python
#coding:utf-8
# Purpose: example make_refshett.py
# Created: 05.02.2011
# Copyright (C) 2011, Manfred Moitzi
# License: MIT license
from __future__ import unicode_literals, print_function, division
__author__ = "mozman <*****@*****.**>"
import ezodf
NCOLS = 10
NROWS = 10
ods = ezodf.newdoc('ods', 'refsheet.ods')
sheet = ezodf.Sheet('REFS', size=(NROWS, NCOLS))
ods.sheets += sheet
for row in range(NROWS):
for col in range(NCOLS):
content = chr(ord('A') + col) + str(row + 1)
sheet[row, col].set_value(content)
ods.save()
#!/usr/bin/env python
#coding:utf-8
# Purpose: empty spreadsheet
# Created: 26.01.2011
# Copyright (C) 2011, Manfred Moitzi
# License: MIT license
from __future__ import unicode_literals, print_function, division
__author__ = "mozman <*****@*****.**>"
import ezodf
ods = ezodf.newdoc('ods', "empty_spreadsheet.ods")
for sheetname in ['SHEET1', 'SHEET2', 'SHEET3']:
ods.sheets += ezodf.Sheet(name=sheetname, size=(20, 10))
ods.save()
#!/usr/bin/env python
#coding:utf-8
# Purpose: example spreadhet with formula
# Created: 06.02.2011
# Copyright (C) 2011, Manfred Moitzi
# License: MIT license
from __future__ import unicode_literals, print_function, division
__author__ = "mozman <*****@*****.**>"
import ezodf
ods = ezodf.newdoc('ods')
sheet = ezodf.Sheet('SUM Formula')
ods.sheets += sheet
for col in range(5):
for row in range(10):
sheet[row, col].set_value(col * 10. + row)
sheet['F9'].set_value("Summe:")
sheet['F10'].formula = 'of:=SUM([.A1:.E10])'
sheet['F1'].formula = 'of:=SUM([.A1];[.B1];[.C1];[.D1];[.E1])'
ods.saveas('sum_formula.ods')
#!/usr/bin/env python
#coding:utf-8
# Purpose: simple spreadsheet
# Created: 26.01.2011
# Copyright (C) 2011, Manfred Moitzi
# License: MIT license
from __future__ import unicode_literals, print_function, division
__author__ = "mozman <*****@*****.**>"
import ezodf
ods = ezodf.newdoc('ods', "simple_spreadsheet.ods")
sheet = ezodf.Sheet('NUMBERS', size=(20, 10))
ods.sheets += sheet
for index in range(sheet.ncols()):
sheet[5, index].set_value(index)
sheet[index, 5].set_value(index)
sheet[index, index].set_value(index, value_type='currency', currency='EUR')
sheet = ezodf.Sheet('TEXT', size=(20, 10))
ods.sheets += sheet
for column in range(sheet.ncols()):
for row, cell in enumerate(sheet.column(column)):
cell.set_value("Cell (%d, %d)" % (row, column))
ods.save()
def generate_charts(csvfile, bridges):
# Fill predefined ods file with collected data.
# csvfile: the .csv file generated by the loopback_test application
# bridges: list of targeted bridges
global verbose
info('\nGenerating charts...')
# Build input CSV Files List (depends on target list)
try:
debug('Targeted bridge(s): {}'.format(bridges))
debug('CSV File: {}'.format(csvfile))
prefix = os.path.splitext(csvfile)[0] # remove file extension
debug('prefix: {}'.format(prefix))
csvfiles = {'Aggregated': '{}_agg.csv'.format(prefix)}
for i in range(len(bridges)):
csvfiles[bridges[i]] = '{}_{}.csv'.format(prefix, bridges[i])
debug('Input CSV files list: {}'.format(csvfiles))
except Exception as e:
err("Failed to build input CSV Files List!")
if verbose:
traceback.print_exc()
raise e
# Read input CSV Files to retrieve data
try:
csvfiledata = {}
for k in csvfiles.keys():
csvfiledata[k] = readCSVFile(csvfiles[k])
alldata = readCSVFile(csvfile)
except Exception as e:
err("Failed to read input CSV Files!")
debug('Key: {}. CSV File: {}'.format(k, csvfiles[k]))
if verbose:
traceback.print_exc()
raise e
# Clone charts spreadsheet from template, and open it
try:
odsfilename = '{}_charts.ods'.format(prefix)
debug('.ods filename: {}'.format(odsfilename))
shutil.copy(CHARTS_TEMPLATE, odsfilename)
# Retrieve .ods file sheets
spreadsheet = ezodf.opendoc(odsfilename)
sheets = spreadsheet.sheets
except Exception as e:
err("Failed to clone charts spreadsheet from template!")
if verbose:
traceback.print_exc()
# Save changes into file
spreadsheet.save()
raise e
# Fill chart tables with respective data
try:
rowcount = len(csvfiledata['Aggregated'])
colcount = len(csvfiledata['Aggregated'][0])
debug('Row count: {}'.format(rowcount))
debug('Column count: {}'.format(colcount))
for r in range(1, rowcount): # first row is .csv header
for k in csvfiles.keys():
src_row = csvfiledata[k][r]
dest_row = r + 1 # +2 row offset in .ods file vs .csv
for c in range(colcount):
dest_cell = sheets[k][dest_row, c]
if c < 4:
src_val = src_row[c]
else:
src_val = int(src_row[c])
dest_cell.set_value(src_val)
except Exception as e:
err("Failed to fill chart tables with respective data!")
debug("Row: {}. Key: {}. Col: {}. Data={}".format(
r, k, c, src_row[c]))
if verbose:
traceback.print_exc()
# Save changes into file
spreadsheet.save()
raise e
# Remove unused sheets
if len(csvfiles) != len(sheets):
for s in sheets:
if s.name != 'Aggregated' and s.name not in bridges:
debug('Removing {} sheet (not used).'.format(s.name))
del sheets[s.name]
# Copy all data from csvfile into last sheet
# NB: add to use this method (create a new sheet and fill it) because of
# some weird issue. If the sheet was already completed (like the previous
# ones), code would crash, reported list index to be out of range.
try:
rowcount = len(alldata)
colcount = len(alldata[0])
debug('All data Row count: {}'.format(rowcount))
debug('All data Column count: {}'.format(colcount))
sheets += ezodf.Sheet('Data')
sheets['Data'].append_rows(rowcount)
sheets['Data'].append_columns(colcount)
for r in range(rowcount):
for c in range(colcount):
src_row = alldata[r]
dest_cell = sheets['Data'][r, c]
if (r == 0) or (c < 4):
src_val = src_row[c]
else:
src_val = int(src_row[c])
dest_cell.set_value(src_val)
except Exception as e:
err("Failed to copy all data from csvfile into last sheet!")
debug("Row: {}. Col: {}. Data={}".format(r, c, src_row[c]))
if verbose:
traceback.print_exc()
# Save changes into file
spreadsheet.save()
raise e
# Save changes into file
spreadsheet.save()
info("Completed. Charts saved into:\n {} file.".format(odsfilename))
