Esempio n. 1
0
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]
Esempio n. 2
0
def get_odf_spreadsheet(sheets):
    """Creates a spreadsheet from a dictionary sheets of
	dictionary entries sheetname -> nested list of rows"""
    doc = OpenDocumentSpreadsheet()
    spreadsheet = doc.spreadsheet
    for sheet_name, list_rows in sheets.iteritems():
        sheet = Table()
        spreadsheet.addElement(sheet)
        sheet.setAttribute("name", sheet_name)
        for list_row in list_rows:
            table_row = TableRow()
            for cell_content in list_row:
                vtype = valuetype(cell_content)
                if vtype == "boolean":
                    cell_content = ("True" if cell_content else "False")
                    vtype = "string"
                elif vtype == "string":
                    cell_content = unicodedata.normalize(
                        'NFKD',
                        unicode(cell_content)).encode('ascii', 'ignore')
                table_cell = TableCell(valuetype=vtype, value=cell_content)
                if vtype == "string":
                    s = str(cell_content)
                    table_cell.addElement(P(text=s))
                table_row.addElement(table_cell)
            sheet.addElement(table_row)
    st = StringIO()
    doc.write(st)
    return st.getvalue()
Esempio n. 3
0
 def insertColumn(self, sheetname, columnname, columnnumber):
     """Inserts a new empty column into the current doc.
     @param sheetname: The name of the sheet to be added to.
     @type sheetname: string
     @param columnname: The name of the new column to be added
     @type columnname: string
     @param columnnumber: Where to insert the new column (= how many come before it?)
     @type columnnumber: int
     """
     sheets = self._doc.spreadsheet.getElementsByType(Table)
     for sheet in sheets:
         if sheet.getAttribute('name') == sheetname:
             rownum = 0
             rows   = sheet.getElementsByType(TableRow)
             for row in rows:
                 colNum = 0
                 cells  = row.getElementsByType(TableCell)
                 for cell in cells:
                     if colNum == columnnumber:
                         newCell = TableCell()
                         if rownum == 0:
                             p = P()
                             p.addText(unicode(columnname))
                             newCell.addElement(p)
                         else:
                             p = P()
                             p.addText(unicode(''))
                             newCell.addElement(p)
                         row.insertBefore(newCell, cell)
                     colNum += 1
                 rownum += 1
 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)
Esempio n. 5
0
 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)
Esempio n. 6
0
 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)
Esempio n. 7
0
    def _write_cells(
        self,
        cells: list[ExcelCell],
        sheet_name: str | None = None,
        startrow: int = 0,
        startcol: int = 0,
        freeze_panes: tuple[int, int] | None = None,
    ) -> None:
        """
        Write the frame cells using odf
        """
        from odf.table import (
            Table,
            TableCell,
            TableRow,
        )
        from odf.text import P

        sheet_name = self._get_sheet_name(sheet_name)
        assert sheet_name is not None

        if sheet_name in self.sheets:
            wks = self.sheets[sheet_name]
        else:
            wks = Table(name=sheet_name)
            self.book.spreadsheet.addElement(wks)

        if validate_freeze_panes(freeze_panes):
            freeze_panes = cast(Tuple[int, int], freeze_panes)
            self._create_freeze_panes(sheet_name, freeze_panes)

        for _ in range(startrow):
            wks.addElement(TableRow())

        rows: DefaultDict = defaultdict(TableRow)
        col_count: DefaultDict = defaultdict(int)

        for cell in sorted(cells, key=lambda cell: (cell.row, cell.col)):
            # only add empty cells if the row is still empty
            if not col_count[cell.row]:
                for _ in range(startcol):
                    rows[cell.row].addElement(TableCell())

            # fill with empty cells if needed
            for _ in range(cell.col - col_count[cell.row]):
                rows[cell.row].addElement(TableCell())
                col_count[cell.row] += 1

            pvalue, tc = self._make_table_cell(cell)
            rows[cell.row].addElement(tc)
            col_count[cell.row] += 1
            p = P(text=pvalue)
            tc.addElement(p)

        # add all rows to the sheet
        if len(rows) > 0:
            for row_nr in range(max(rows.keys()) + 1):
                wks.addElement(rows[row_nr])
Esempio n. 8
0
    def _make_table_cell(self, cell) -> tuple[object, 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):
            # Fast formatting
            value = val.isoformat()
            # Slow but locale-dependent
            pvalue = val.strftime("%c")
            return (
                pvalue,
                TableCell(valuetype="date",
                          datevalue=value,
                          attributes=attributes),
            )
        elif isinstance(val, datetime.date):
            # Fast formatting
            value = f"{val.year}-{val.month:02d}-{val.day:02d}"
            # Slow but locale-dependent
            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,
                ),
            )
Esempio n. 9
0
def addcell(tr, val, lestyle):
    if val == 'True':
        val = "Oui"
    if val == 'False':
        val = "Non"
    tc = TableCell(stylename=lestyle)
    tr.addElement(tc)
    p = P(text=val)
    tc.addElement(p)
Esempio n. 10
0
    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)
Esempio n. 11
0
 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() )
Esempio n. 12
0
def cell(tr, val, style=None):
    print "[cell] type=%s" % str(type(val))
    print "[cell] type=%s" % str(val)
    if style is None:
        tc = TableCell(valuetype=valuetype(val), value=str(val))
    else:
        tc = TableCell(stylename=style, valuetype=valuetype(val), value=str(val))
    tr.addElement(tc)
    p = P(stylename=tablecontents, text=str(val))
    tc.addElement(p)
Esempio n. 13
0
    def write_captions(self, sheet, table):
        """ Writes sheet's caption row to table.
        """

        row = TableRow()
        for caption in sheet.captions:
            cell = TableCell()
            cell.addElement(P(text=caption))
            row.addElement(cell)
        table.addElement(row)
Esempio n. 14
0
 def sumtable():
     ad = {u"Напряжение" : u' (В)', u"Ток" : u' (А)', u"Мощность" : u' (Вт/c)'}
     table = Table()
     table.addElement(TableColumn(numbercolumnsrepeated = len(ampl)+1, stylename = tablestyle))
     tr = TableRow()
     tc = TableCell()
     tr.addElement(tc)
     for a in ampl:
         tr.addElement(ttb(tabletextbold, a))
     table.addElement(tr)
     for antenna in sorted(dictwire[wire].keys()):
         tr = TableRow()
         tr.addElement(ttb(tabletextbold, antenna))
         table.addElement(tr)
         for port in sorted(dictwire[wire][antenna].keys()):
             for m in [u"Напряжение", u"Ток", u"Мощность"]:
                 tr = TableRow()
                 tr.addElement(ttb(tabletextbold, m+ad[m]))
                 if port is not None:
                     tr.addElement(ttb(tabletextbold, port))
                 table.addElement(tr)
                 for rg in sorted(dictwire[wire][antenna][port].keys()):
                     for k in dictwire[wire][antenna][port][rg].keys():
                         if k != None:
                             b = sorted(dictwire[wire][antenna][port][rg].keys(), key = len)
                         else:
                             b = dictwire[wire][antenna][port][rg].keys()
                     for distance in b:
                         tr = TableRow()
                         tc = TableCell()
                         try:
                             p = P(text = distance + ', ' + rg)
                         except:
                             p = P(text = rg)
                         tc.addElement(p)
                         tr.addElement(tc)
                         for amplitude in ampl:
                             try:
                                 if m == u"Мощность":
                                     a = data[dictwire[wire][antenna][port][rg][distance][amplitude][u"Напряжение"]]
                                     amu = a.energy((0,len(a.xvalue)), bytime = True)
                                     amu = '{0:.03e}'.format(amu)
                                     wiretype = a.params['wiretype']
                                 else:
                                     a = data[dictwire[wire][antenna][port][rg][distance][amplitude][m]]
                                     amu = a.max()
                                     amu = '{0:.03f}'.format(amu)
                                     wiretype = a.params['wiretype']
                             except KeyError:
                                 amu = u'--'
                             tr.addElement(ttb(tabletext, amu))
                         table.addElement(tr)
     return [table, wiretype]
Esempio n. 15
0
 def AddCell(self, attributes=None, rowspan=1, colspan=1):
     tc = TableCell(attributes=attributes)
     tc.number = self.nextcell
     self.nextcell += colspan
     tc.setAttribute('numberrowsspanned', str(rowspan))
     tc.setAttribute('numbercolumnsrepeated', str(colspan))
     tc.setAttribute('numbercolumnsspanned', str(colspan))
     self.row.addElement(tc)
     return tc
Esempio n. 16
0
    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)
Esempio n. 17
0
 def _writeodsitem(self, col, value):
     """Uses col and value to make entry in ods file (using self.currentrow)"""
     # column numbering starts at 1 for spreadsheet column A
     curcol = 0 ### restarts at beginning of row for each entry
     targetcol = col
     r = self.currentrow
     for c in r.childNodes:
         if c.tagName != 'table:table-cell': continue
         repeatedcols = c.getAttribute('numbercolumnsrepeated')
         repcount = int(repeatedcols) if repeatedcols else 1
         if curcol + repcount >= targetcol: break
         curcol += repcount
     else:
         pass ### got to end of row without finding desired column; add more cells? or report bad col?
     ### doesn't preserve background color (see Time Zones for example)
     countbefore = targetcol - curcol - 1
     countafter = curcol + repcount - targetcol
     if countbefore > 0:
         c1 = TableCell()
         c1.setAttribute('numbercolumnsrepeated', str(countbefore))
         c.setAttribute('numbercolumnsrepeated', str(countafter + 1))
         x = r.insertBefore(c1, c)
     if countafter > 0:
         c.setAttribute('numbercolumnsrepeated', '1')
         c2 = TableCell()
         c2.setAttribute('numbercolumnsrepeated', str(countafter))
         if c == r.lastChild:
             x = r.appendChild(c2)
         else:
             x = r.insertBefore(c2, c.nextSibling)
     if c.hasChildNodes():
         ### perhaps should test that child is text:p and its child is Text
         c.firstChild.firstChild.data = value
     else:
         c.addElement(P(text=value))
Esempio n. 18
0
 def addTable(self,tabledata,headers,formater=None):
     if formater and len(formater)!=len(tabledata):
         raise ValueError
     if formater is None:
         formater = [[""]*len(tabledata[0])]*len(tabledata)
     table = Table()
     columns = len(headers)
     table.addElement(TableColumn(numbercolumnsrepeated=columns))
     tr = TableRow()
     table.addElement(tr)
     for header in headers:
         tc = TableCell(stylename="Table")
         tr.addElement(tc)
         p = P(stylename=self.tableheaders,text=header)
         tc.addElement(p)
     for line,formats in zip(tabledata,formater):
         tr = TableRow()
         table.addElement(tr)
         for column,cformat in zip(line,formats):
             if cformat == "centerred":
                 cellformat = self.tablecontentscenter
             elif cformat == "center":
                 cellformat = self.tablecontentscenterred
             else:
                 cellformat = self.tablecontents
             tc = TableCell(stylename="Table")
             tr.addElement(tc)
             p = P(stylename=cellformat,text=column)
             tc.addElement(p)
     self.textdoc.text.addElement(table)
Esempio n. 19
0
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 addTableOnBookmark(self, bookmarkName, tableData, enumerated=False):
        '''Вставка таблицы перед закладкой
		'''
        table_columns = 3 if enumerated else 2
        #Создание и заполнение таблицы
        table = Table()
        table.addElement(TableColumn(numbercolumnsrepeated=table_columns))
        for index, row in enumerate(tableData):
            tr = TableRow()
            table.addElement(tr)
            if enumerated:
                tc = TableCell()
                tr.addElement(tc)
                tc.addElement(P(text=str(index + 1)))
            for item in row:
                tc = TableCell()
                tr.addElement(tc)
                tc.addElement(
                    P(text=str(item) if type(item) != QVariant else ''))
        bookmarks = self.doc.getElementsByType(BookmarkStart)
        #Вставка таблицы в content.xml
        for bookmark in bookmarks:
            if bookmark.getAttribute("name") == bookmarkName:
                bookmark.parentNode.parentNode.insertBefore(
                    table, bookmark.parentNode)
                bookmark.parentNode.parentNode.insertBefore(
                    P(text=""), bookmark.parentNode)
        self.doc.save(root + r"/releasedDocs/Документ", True)
Esempio n. 21
0
	def make_row(self, row):
		""" For each item in array add a cell to a row """
		tr = TableRow()
		for cell_text in row:
			try:
				#i = int(cell_text)
				tc = TableCell(formula=cell_text)
			except:
				tc = TableCell()
				txt = P(text=cell_text)
				tc.addElement(txt)

			tr.addElement(tc)

		return tr
Esempio n. 22
0
 def _copycell(odfcell, **kwargs):
     kw = {}
     for _, attr in odfcell.attributes.keys():
         attr = attr.replace('-', '')
         kw[attr] = odfcell.getAttribute(attr)
     kw.update(kwargs)
     return TableCell(**kw)
Esempio n. 23
0
    def get_sheet_data(self, sheet, convert_float: bool) -> List[List[Scalar]]:
        """
        Parse an ODF Table into a list of lists
        """
        from odf.table import (
            CoveredTableCell,
            TableCell,
            TableRow,
        )

        covered_cell_name = CoveredTableCell().qname
        table_cell_name = TableCell().qname
        cell_names = {covered_cell_name, table_cell_name}

        sheet_rows = sheet.getElementsByType(TableRow)
        empty_rows = 0
        max_row_len = 0

        table: List[List[Scalar]] = []

        for i, sheet_row in enumerate(sheet_rows):
            sheet_cells = [x for x in sheet_row.childNodes if x.qname in cell_names]
            empty_cells = 0
            table_row: List[Scalar] = []

            for j, sheet_cell in enumerate(sheet_cells):
                if sheet_cell.qname == table_cell_name:
                    value = self._get_cell_value(sheet_cell, convert_float)
                else:
                    value = self.empty_value

                column_repeat = self._get_column_repeat(sheet_cell)

                # Queue up empty values, writing only if content succeeds them
                if value == self.empty_value:
                    empty_cells += column_repeat
                else:
                    table_row.extend([self.empty_value] * empty_cells)
                    empty_cells = 0
                    table_row.extend([value] * column_repeat)

            if max_row_len < len(table_row):
                max_row_len = len(table_row)

            row_repeat = self._get_row_repeat(sheet_row)
            if self._is_empty_row(sheet_row):
                empty_rows += row_repeat
            else:
                # add blank rows to our table
                table.extend([[self.empty_value]] * empty_rows)
                empty_rows = 0
                for _ in range(row_repeat):
                    table.append(table_row)

        # Make our table square
        for row in table:
            if len(row) < max_row_len:
                row.extend([self.empty_value] * (max_row_len - len(row)))

        return table
Esempio n. 24
0
 def skills(self) :
     t = self.doc.text
     t.addElement(P(text='RELEVANT SKILLS', stylename="Heading"))
     table = Table(name="skills-table")
     col = 0
     skills_cols = int(self.config.fetch('skills_cols'))
     table.addElement(TableColumn(numbercolumnsrepeated=skills_cols))
     for skill in Resume.skills(self) :
         if col % skills_cols == 0 :
             tr = TableRow()
             table.addElement(tr)
         tc = TableCell(valuetype="string")
         tc.addElement(P(text=skill,stylename="List"))
         tr.addElement(tc)             
         col += 1
     t.addElement(table)
Esempio n. 25
0
    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"'''))
Esempio n. 26
0
 def addTable(self, content, cell_style, column_styles=[]):
     cell_style = getattr(self, cell_style, None)
     table = Table()
     for style in column_styles: 
         if "stylename" in style.keys():
             style["stylename"] = getattr(self, style["stylename"], None)
         table.addElement(TableColumn(**style))
     for row in content:
         tr = TableRow()
         table.addElement(tr)
         for cell in row:
             tc = TableCell()
             tr.addElement(tc)
             p = P(stylename=cell_style, text=cell)
             tc.addElement(p)
     self.document.text.addElement(table)
Esempio n. 27
0
 def openSpreadsheet(self):
     """(Re)Loads the spreadsheet."""
     self._doc = load(self._filepath)
     
     rows      = self._doc.spreadsheet.getElementsByType(TableRow)
     dataWidth = 1
     
     # Determine data-width (as opposed to trailing blank cells)
     cells = rows[0].getElementsByType(TableCell)
     for cell in cells[1:]:
         pl = cell.getElementsByType(P)
         if len(pl) > 0 and (pl[0].firstChild) and len(unicode(pl[0].firstChild)) > 0:
             dataWidth += 1
         else:
             break
     
     # Expand out / decompress repeated cells (e.g. number-columns-repeated="2")
     for row in rows:
         cells  = row.getElementsByType(TableCell)
         colNum = 0
         for cell in cells:
             if colNum < dataWidth:
                 repeated = int(cell.getAttribute('numbercolumnsrepeated') or 0)
                 pl = cell.getElementsByType(P)
                 if repeated > 1:
                     if len(pl) > 0 and (pl[0].firstChild) and len(unicode(pl[0].firstChild)) > 0:
                         for i in range(repeated):
                             c = TableCell()
                             p = P()
                             p.addText(unicode(pl[0].firstChild))
                             c.addElement(p)
                             row.insertBefore(c, cell)
                         row.removeChild(cell)
                     else:
                         for i in range(min(repeated, dataWidth-colNum)):
                             c = TableCell()
                             p = P()
                             p.addText(unicode(''))
                             c.addElement(p)
                             row.insertBefore(c, cell)
                         row.removeChild(cell)
             else:
                 row.removeChild(cell)
             colNum += 1
             
         # Add a constant 3 trailing columns
         for i in range(3):
             c = TableCell()
             p = P()
             p.addText(unicode(''))
             c.addElement(p)
             row.addElement(c)
Esempio n. 28
0
 def AddCell(self, attributes=None, rowspan=1, colspan=1):
     tc = TableCell(attributes=attributes)
     tc.number = self.nextcell
     self.nextcell += colspan
     tc.setAttribute('numberrowsspanned', str(rowspan))
     tc.setAttribute('numbercolumnsrepeated', str(colspan))
     tc.setAttribute('numbercolumnsspanned', str(colspan))
     self.row.addElement(tc)
     return tc
Esempio n. 29
0
    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)
Esempio n. 30
0
    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)
Esempio n. 31
0
    def write_row(self, sheet_row, table):
        """ Appends ``sheet_row`` data into table.
        """

        row = TableRow()
        for field in sheet_row:
            if isinstance(field, datetime.datetime):
                field = unicode(field.strftime('%Y-%m-%d %H:%M:%S'))
            elif isinstance(field, datetime.date):
                field = unicode(field.strftime('%Y-%m-%d'))
            elif not isinstance(field, unicode):
                field = unicode(field)
            cell = TableCell()
            cell.addElement(P(text=field))
            row.addElement(cell)

        table.addElement(row)
Esempio n. 32
0
 def addTable(self, content, cell_style, column_styles=[]):
     """  """
     cell_style = getattr(self, cell_style, None)
     table = Table()
     for style in column_styles:
         if "stylename" in style.keys():
             style["stylename"] = getattr(self, style["stylename"], None)
             table.addElement(TableColumn(**style))
     for row in content:
         tr = TableRow()
         table.addElement(tr)
         for cell in row:
             tc = TableCell()
             tr.addElement(tc)
             p = P(stylename=cell_style,text=cell)
             tc.addElement(p)
     self.document.text.addElement(table)
Esempio n. 33
0
def write_text():
    """Write to output file ordinary elements.

    This function is called every tame, we collect whole paragraph or block of elements in 'string_to_write'
    We write every block or paragraph in it's own cell in the first column of output file.
    After writing we shift down current row and clean 'string_to_write' in order to collect next elements.

    """
    global string_to_write
    global header_level
    global ordered
    global bullet
    global table
    global separator
    global content
    row = TableRow()
    cell = TableCell()
    if header_level != 0 and header_level > 0:
        if header_level > (len(header) -
                           1):  # if there are headers with lvl bigger than 2
            for i in range(
                    len(header), header_level +
                    1):  # creating names for headers with lvl bigger than 2
                header.append('header' + str(i))
        add_style(cell, header[header_level])
        if header_level == separator:  # if separator was set, we will create new sheet in document
            if table.hasChildNodes():
                write_sheet()
            table = Table(
                name=string_to_write
            )  # creating new sheet with separating header as name
    else:
        add_style(cell, simple_text)
    if bullet:
        string_to_write = '- ' + string_to_write
    if ordered > 0:
        string_to_write = str(ordered) + ') ' + string_to_write
        ordered = ordered + 1
    content.addText(string_to_write)
    cell.addElement(content)
    content = P()
    count_height(row, cell)
    row.addElement(cell)
    table.addElement(row)
    string_to_write = ''
Esempio n. 34
0
 def write_cell(self, row, cell):
     """write a native cell"""
     cell_to_be_written = TableCell()
     cell_type = type(cell)
     cell_odf_type = ODS_WRITE_FORMAT_COVERSION.get(cell_type, "string")
     cell_to_be_written.setAttrNS(OFFICENS, "value-type", cell_odf_type)
     cell_odf_value_token = VALUE_TOKEN.get(cell_odf_type, "value")
     converter = ODS_VALUE_CONVERTERS.get(cell_odf_type, None)
     if converter:
         cell = converter(cell)
     if cell_odf_type != 'string':
         cell_to_be_written.setAttrNS(OFFICENS, cell_odf_value_token, cell)
         cell_to_be_written.addElement(P(text=cell))
     else:
         lines = cell.split('\n')
         for line in lines:
             cell_to_be_written.addElement(P(text=line))
     row.addElement(cell_to_be_written)
Esempio n. 35
0
def create_odf_table_row(data, first=""):
    """
    returns a odt table row that contains the passed data in odf table cells

    input:
        first   style scheme of the first row's cells

    output:
        row     the created table row containing cells with corresponding data

    """
    row = TableRow()

    for i, item in enumerate(data):

        # we need to distinguish between first column, middle columns and last
        # columns. The first and the last have outer borders, while the middle
        # have not. If we draw the first row, skip this and use the passed
        # style.
        if not first:

            # first
            if i == 0:
                style = "col_left"

            # last
            elif i == (len(data)-1):
                style = "col_right"

            # middle
            else:
                style = "col_middle"

        else:
            style = first

        logger.debug("cell content (i=%d):%s, style=%s", i, item, style)

        cell = TableCell(valuetype= 'string', stylename=style)
        cell.addElement(P(text=item, stylename="default"))
        row.addElement(cell)

    return row
Esempio n. 36
0
def create_odf_table_row(data, first=""):
    """
    returns a odt table row that contains the passed data in odf table cells

    input:
        first   style scheme of the first row's cells

    output:
        row     the created table row containing cells with corresponding data

    """
    row = TableRow()

    for i, item in enumerate(data):

        # we need to distinguish between first column, middle columns and last
        # columns. The first and the last have outer borders, while the middle
        # have not. If we draw the first row, skip this and use the passed
        # style.
        if not first:

            # first
            if i == 0:
                style = "col_left"

            # last
            elif i == (len(data) - 1):
                style = "col_right"

            # middle
            else:
                style = "col_middle"

        else:
            style = first

        logger.debug("cell content (i=%d):%s, style=%s", i, item, style)

        cell = TableCell(valuetype='string', stylename=style)
        cell.addElement(P(text=item, stylename="default"))
        row.addElement(cell)

    return row
Esempio n. 37
0
 def moneycell(self, m, formula=None, style=None):
     a = { "valuetype": "currency",
           "currency": "GBP",
           "stylename": style if style else self.currencystyle,
     }
     if m is not None:
         a["value"] = str(m)
     if formula is not None:
         a["formula"] = formula
     return TableCell(**a)
Esempio n. 38
0
 def write_cell(self, row, cell):
     tc = TableCell()
     cell_type = type(cell)
     cell_odf_type = ODS_WRITE_FORMAT_COVERSION.get(cell_type, "string")
     tc.setAttrNS(OFFICENS, "value-type", cell_odf_type)
     cell_odf_value_token = VALUE_TOKEN.get(cell_odf_type, "value")
     converter = ODS_VALUE_CONVERTERS.get(cell_odf_type, None)
     if converter:
         cell = converter(cell)
     if cell_odf_type != 'string':
         tc.setAttrNS(OFFICENS, cell_odf_value_token, cell)
         tc.addElement(P(text=cell))
     else:
         lines = cell.split('\n')
         for line in lines:
             tc.addElement(P(text=line))
     row.addElement(tc)
Esempio n. 39
0
def convert_FFPtable_day(path):
    name = "FFPtable.day"

    table = Table(name=name)
    with open(path) as fin:
        line = fin.readline().split()[2:]
        row = TableRow()
        for year in line:
            table.addElement(TableColumn())
            cell = TableCell(valuetype="float", value=year)
            row.addElement(cell)
        table.addElement(row)

        for line in fin.readlines():
            line = line.split()[2:]
            row = TableRow()
            for item in line:
                cell = TableCell(valuetype="float", value=item)
                row.addElement(cell)
            table.addElement(row)
    return table
Esempio n. 40
0
    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
Esempio n. 41
0
 def insertColumn(self, sheetname, columnname, columnnumber):
     """Inserts a new empty column into the current doc.
     @param sheetname: The name of the sheet to be added to.
     @type sheetname: string
     @param columnname: The name of the new column to be added
     @type columnname: string
     @param columnnumber: Where to insert the new column (= how many come before it?)
     @type columnnumber: int
     """
     sheets = self._doc.spreadsheet.getElementsByType(Table)
     for sheet in sheets:
         if sheet.getAttribute('name') == sheetname:
             rownum = 0
             rows = sheet.getElementsByType(TableRow)
             for row in rows:
                 colNum = 0
                 cells = row.getElementsByType(TableCell)
                 for cell in cells:
                     if colNum == columnnumber:
                         newCell = TableCell()
                         if rownum == 0:
                             p = P()
                             p.addText(StringUtils.toUnicode(columnname))
                             newCell.addElement(p)
                         else:
                             p = P()
                             p.addText(StringUtils.toUnicode(''))
                             newCell.addElement(p)
                         row.insertBefore(newCell, cell)
                     colNum += 1
                 rownum += 1
Esempio n. 42
0
def export_ods (headers, data):
    doc = OpenDocumentSpreadsheet()
    style = Style(name="Large number", family="table-cell")
    style.addElement(TextProperties(fontfamily="Arial", fontsize="15pt"))
    doc.styles.addElement(style)
    widewidth = Style(name="co1", family="table-column")
    widewidth.addElement(TableColumnProperties(columnwidth="2.8cm", breakbefore="auto"))
    doc.automaticstyles.addElement(widewidth)

    table = Table()
    if len (headers) > 0:
        tr = TableRow ()
        table.addElement (tr)
        for item in headers:
            tc = TableCell ()
            tr.addElement (tc)
            p = P(stylename = style, text = txt(item))
            tc.addElement (p)

    for line in data:
        tr = TableRow ()
        table.addElement (tr)
        for item in line:
            tc = TableCell ()
            tr.addElement (tc)
            p = P (stylename = style, text = txt(item))
            tc.addElement (p)

    doc.spreadsheet.addElement(table)
    buffer = StringIO ()
    doc.write(buffer)

    return buffer.getvalue ()
Esempio n. 43
0
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
Esempio n. 44
0
 def add_title(self, title, width):
     row = TableRow()
     cell = TableCell(stylename="title")
     cell.setAttrNS(TABLENS, "number-columns-spanned", width)
     cell.addElement(P(text=title))
     row.addElement(cell)
     self.sheet.addElement(row)
Esempio n. 45
0
def write_image(image):
    """Write to output file image elements.

    Since, element with title 'Image' has special structure of 'c'(Content) field, that looks like:
    [[0], [1], [2]]
    where:
        [0] - list of attributes: identifier, classes, key-value pairs:
            ['id', [], [ ... , ['weight', '...in'], ['height', '...in'], ... ] - we get sizes there.
        [1] - caption.
        [2] - ['src', 'title'] - source and title of image.
    we should parse it especially.

    Args:
        image - element with title 'Image'.

    """
    global image_counter
    global saved_hr
    if image_counter == -1:
        return
    if image_counter == 0:
        saved_hr = load_images(args.input, ods)
        if len(saved_hr) == 0:
            image_counter = -1
            return
    if string_to_write:
        write_text()
    row = TableRow()
    cell = TableCell()
    w, h = count_size(image['c'][0][2], row)
    frame = Frame(width=w, height=h)
    img = Image(href=saved_hr[image_counter])

    table.addElement(row)
    row.addElement(cell)
    cell.addElement(frame)
    frame.addElement(img)

    image_counter = image_counter + 1
Esempio n. 46
0
 def creerCellule(self, donnee, **kwargs):
     tc = TableCell(valuetype="string")
     nbCellulesRecouvertes = kwargs.get('numbercolumnsspanned', None)
     if nbCellulesRecouvertes:
         tc = TableCell(valuetype="string",
                        numbercolumnsspanned=int(nbCellulesRecouvertes))
     tc.addElement(P(text=str(donnee)))
     return tc
Esempio n. 47
0
    def addElementToRow(self, element, elementType, tableRow, tablecontents):
        if elementType == "float":
            tc = TableCell(valuetype=elementType, value=element.strip())
        else:
            tc = TableCell(valuetype=elementType)

        tableRow.addElement(tc)
        p = P(stylename=tablecontents, text=element)
        tc.addElement(p)
Esempio n. 48
0
 def write_cell(self, row, x):
     tc = TableCell()
     x_type = type(x)
     x_odf_type = ODS_WRITE_FORMAT_COVERSION.get(x_type, "string")
     tc.setAttrNS(OFFICENS, "value-type", x_odf_type)
     x_odf_value_token = VALUE_TOKEN.get(x_odf_type, "value")
     converter = ODS_VALUE_CONVERTERS.get(x_odf_type, None)
     if converter:
         x = converter(x)
     if x_odf_type != 'string':
         tc.setAttrNS(OFFICENS, x_odf_value_token, x)
     tc.addElement(P(text=x))
     row.addElement(tc)
    def write_cell(self, value, **kwargs):
        if "numbercolumnsspanned" in kwargs or "numberrowsspanned" in kwargs:
            kwargs.setdefault("numberrowsspanned", "1")
            kwargs.setdefault("numbercolumnsspanned", "1")

        cell = TableCell(**kwargs)
        cell.setAttrNS(OFFICENS, "value-type", "string")

        if isinstance(value, Element):
            para = P()
            para.addElement(value)
            cell.addElement(para)
        else:
            for line in value.split("\n"):
                cell.addElement(P(text=line))

        self._row.addElement(cell)
Esempio n. 50
0
    def _get_cell(self, label, stylename=None):
        """
        Build a TableCell and adapt the format to the provided label format

        :param label: The data to write (int/float/bool/date/str/unicode)
        :param str stylename: One of the stylenames added in the __init__
        :returns: A TableCell instance
        """
        if stylename is not None:
            cell_to_be_written = TableCell(stylename=stylename)
        else:
            cell_to_be_written = TableCell()
        cell_type = type(label)
        cell_odf_type = converter.ODS_WRITE_FORMAT_COVERSION.get(
            cell_type,
            "string"
        )
        cell_to_be_written.setAttrNS(OFFICENS, "value-type", cell_odf_type)
        cell_odf_value_token = converter.VALUE_TOKEN.get(
            cell_odf_type,
            "value",
        )
        converter_func = converter.ODS_VALUE_CONVERTERS.get(
            cell_odf_type,
            None
        )
        if converter_func:
            label = converter_func(label)
        if cell_odf_type != 'string':
            cell_to_be_written.setAttrNS(OFFICENS, cell_odf_value_token, label)
            cell_to_be_written.addElement(P(text=label))
        else:
            lines = label.split('\n')
            for line in lines:
                cell_to_be_written.addElement(P(text=line))
        return cell_to_be_written
Esempio n. 51
0
def convert_FFPtable_USO(path):
    name = "FFPtable.uso"
    table = Table(name=name)
    with open(path) as fin:
        for i in range(2):
            table.addElement(TableColumn())

        for line in fin.readlines():
            line = line.split()
            row = TableRow()
            for item in line:
                cell = TableCell(valuetype="float", value=item)
                row.addElement(cell)
            table.addElement(row)
    return table
 def write_cell(self, row, cell):
     """write a native cell"""
     cell_to_be_written = TableCell()
     cell_type = type(cell)
     cell_odf_type = converter.ODS_WRITE_FORMAT_COVERSION.get(
         cell_type, "string")
     cell_to_be_written.setAttrNS(OFFICENS, "value-type", cell_odf_type)
     cell_odf_value_token = converter.VALUE_TOKEN.get(
         cell_odf_type, "value")
     converter_func = converter.ODS_VALUE_CONVERTERS.get(
         cell_odf_type, None)
     if converter_func:
         cell = converter_func(cell)
     if cell_odf_type != 'string':
         cell_to_be_written.setAttrNS(OFFICENS, cell_odf_value_token, cell)
         cell_to_be_written.addElement(P(text=cell))
     else:
         lines = cell.split('\n')
         for line in lines:
             cell_to_be_written.addElement(P(text=line))
     row.addElement(cell_to_be_written)
Esempio n. 53
0
 def NameDatePair(self, a, b) :
     table = Table(name="t")
     table.addElement(TableColumn(numbercolumnsrepeated="1",
                                  stylename="widecolumn"))
     table.addElement(TableColumn(numbercolumnsrepeated="1",
                                  stylename="narrowcolumn"))
     tr = TableRow()
     tc = TableCell(valuetype="string")
     tc.addElement(P(text=a,stylename="Name"))
     tr.addElement(tc)             
     tc = TableCell(valuetype="string")
     tc.addElement(P(text=b,stylename="RightItalic"))
     tr.addElement(tc)             
     table.addElement(tr)
     return table
Esempio n. 54
0
	def add_attribute_row(self, table, key, value):
		""" Add a two cell row to the table """
		boldstyle = Style(name="Bold",family="text")
		boldstyle.addElement(TextProperties(attributes={'fontweight':"bold"}))

		title_span = Span(stylename=boldstyle, text=key)
		pt = P(text='')
		pt.addElement(title_span)

		tr = TableRow()
		tc = TableCell(valuetype='string')
		tc.addElement(pt)
		tr.addElement(tc)
		tc = TableCell(valuetype='string')
		tc.addElement(P(text=value))
		tr.addElement(tc)
		table.addElement(tr)
Esempio n. 55
0
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)

Esempio n. 56
0
def doit(args) :
    logfile = args.logger
    if args.report: logfile.loglevel = args.report

    try:
        root = ET.parse(args.input).getroot()
    except:
        logfile.log("Error parsing FTML input", "S")

    if args.font:                   # font(s) specified on command line
        fontlist = getfonts( args.font, logfile )
    else:                           # get font spec from FTML fontsrc element
        fontlist = getfonts( [root.find("./head/fontsrc").text], logfile, False )
        #fontlist = getfonts( [fs.text for fs in root.findall("./head/fontsrc")], False ) ### would allow multiple fontsrc elements
    numfonts = len(fontlist)
    if numfonts == 0:
        logfile.log("No font(s) specified", "S")
    if numfonts > 1:
        formattedfontnum = ["{0:02d}".format(n) for n in range(numfonts)]
    else:
        formattedfontnum = [""]
    logfile.log("Font(s) specified:", "V")
    for n, (fontname, bold, italic, embeddedfont) in enumerate(fontlist):
        logfile.log(" " + formattedfontnum[n] + " " + fontname + BoldItalic(bold, italic) + " " + str(embeddedfont), "V")

    # get optional fontscale; compute pointsize as int(12*fontscale/100). If result xx is not 12, then add "fo:font-size=xxpt" in Px styles
    pointsize = 12
    fontscaleel = root.find("./head/fontscale")
    if fontscaleel != None:
        fontscale = fontscaleel.text
        try:
            pointsize = int(int(fontscale)*12/100)
        except ValueError:
            # any problem leaves pointsize 12
            logfile.log("Problem with fontscale value; defaulting to 12 point", "W")

    # Get FTML styles and generate LO writer styles
    # P2 is paragraph style for string element when no features specified
    # each Px (for P3...) corresponds to an FTML style, which specifies lang or feats or both
    # if numfonts > 1, two-digit font number is appended to make an LO writer style for each FTML style + font combo
    # When LO writer style is used with attribute rtl="True", "R" appended to style name
    LOstyles = {}
    ftmlstyles = {}
    Pstylenum = 2
    LOstyles["P2"] = ("", None, None)
    ftmlstyles[0] = "P2"
    for s in root.findall("./head/styles/style"):
        Pstylenum += 1
        Pnum = "P" + str(Pstylenum)
        featstring = ""
        if s.get('feats'):
            featstring = parsefeats(s.get('feats'))
        langname = None
        countryname = None
        lang = s.get('lang')
        if lang != None:
            x = re.match(langcode, lang)
            langname = x.group('langname')
            countryname = x.group('countryname')
        # FTML <test> element @stylename attribute references this <style> element @name attribute
        ftmlstyles[s.get('name')] = Pnum
        LOstyles[Pnum] = (featstring, langname, countryname)

    # create LOwriter file and construct styles for tables, column widths, etc.
    LOdoc = OpenDocumentText()
    init(LOdoc, numfonts)
    # Initialize sequence counters
    sds = SequenceDecls()
    sd = sds.addElement(SequenceDecl(displayoutlinelevel = '0', name = 'Illustration'))
    sd = sds.addElement(SequenceDecl(displayoutlinelevel = '0', name = 'Table'))
    sd = sds.addElement(SequenceDecl(displayoutlinelevel = '0', name = 'Text'))
    sd = sds.addElement(SequenceDecl(displayoutlinelevel = '0', name = 'Drawing'))
    LOdoc.text.addElement(sds)

    # Create Px style for each (featstring, langname, countryname) tuple in LOstyles
    # and for each font (if >1 font, append to Px style name a two-digit number corresponding to the font in fontlist)
    # and (if at least one rtl attribute) suffix of nothing or "R"
    # At the same time, collect info for creating FontFace elements (and any embedded fonts)
    suffixlist = ["", "R"] if root.find(".//test/[@rtl='True']") != None else [""]
    fontfaces = {}
    for p in sorted(LOstyles, key = lambda x : int(x[1:])):  # key = lambda x : int(x[1:]) corrects sort order
        featstring, langname, countryname = LOstyles[p]
        for n, (fontname, bold, italic, embeddedfont) in enumerate(fontlist): # embeddedfont = None if no embedding needed
            fontnum = formattedfontnum[n]
            # Collect fontface info: need one for each font family + feature combination
            # Put embedded font in list only under fontname with empty featstring
            if (fontname, featstring) not in fontfaces:
                fontfaces[ (fontname, featstring) ] = []
            if embeddedfont:
                if (fontname, "") not in fontfaces:
                    fontfaces[ (fontname, "") ] = []
                if embeddedfont not in fontfaces[ (fontname, "") ]:
                    fontfaces[ (fontname, "") ].append(embeddedfont)
            # Generate paragraph styles
            for s in suffixlist:
                pstyle = Style(name=p+fontnum+s, family="paragraph")
                if s == "R":
                    pstyle.addElement(ParagraphProperties(textalign="end", justifysingleword="false", writingmode="rl-tb"))
                pstyledic = {}
                pstyledic['fontnamecomplex'] = \
                pstyledic['fontnameasian'] =\
                pstyledic['fontname'] = fontname + featstring
                pstyledic['fontsizecomplex'] = \
                pstyledic['fontsizeasian'] = \
                pstyledic['fontsize'] = str(pointsize) + "pt"
                if bold:
                    pstyledic['fontweightcomplex'] = \
                    pstyledic['fontweightasian'] = \
                    pstyledic['fontweight'] = 'bold'
                if italic:
                    pstyledic['fontstylecomplex'] = \
                    pstyledic['fontstyleasian'] = \
                    pstyledic['fontstyle'] = 'italic'
                if langname != None:
                    pstyledic['languagecomplex'] = \
                    pstyledic['languageasian'] = \
                    pstyledic['language'] = langname
                if countryname != None:
                    pstyledic['countrycomplex'] = \
                    pstyledic['countryasian'] = \
                    pstyledic['country'] = countryname
                pstyle.addElement(TextProperties(attributes=pstyledic))
#                LOdoc.styles.addElement(pstyle)    ### tried this, but when saving the generated odt, LO changed them to automatic styles
                LOdoc.automaticstyles.addElement(pstyle)

    fontstoembed = []
    for fontname, featstring in sorted(fontfaces):  ### Or find a way to keep order of <style> elements from original FTML?
        ff = FontFace(name=fontname + featstring, fontfamily=fontname + featstring, fontpitch="variable")
        LOdoc.fontfacedecls.addElement(ff)
        if fontfaces[ (fontname, featstring) ]:     # embedding needed for this combination
            for fontfile in fontfaces[ (fontname, featstring) ]:
                fontstoembed.append(fontfile)       # make list for embedding
                ffsrc = FontFaceSrc()
                ffuri = FontFaceUri( **{'href': "Fonts/" + os.path.basename(fontfile), 'type': "simple"} )
                ffformat = FontFaceFormat( **{'string': 'truetype'} )
                ff.addElement(ffsrc)
                ffsrc.addElement(ffuri)
                ffuri.addElement(ffformat)

    basename = "Table1.B"
    colorcount = 0
    colordic = {} # record color #rrggbb as key and "Table1.Bx" as stylename (where x is current color count)
    tablenum = 0

    # get title and comment and use as title and subtitle
    titleel = root.find("./head/title")
    if titleel != None:
        LOdoc.text.addElement(H(outlinelevel=1, stylename="Title", text=titleel.text))
    commentel = root.find("./head/comment")
    if commentel != None:
        LOdoc.text.addElement(P(stylename="Subtitle", text=commentel.text))

    # Each testgroup element begins a new table
    for tg in root.findall("./testgroup"):
        # insert label attribute of testgroup element as subtitle
        tglabel = tg.get('label')
        if tglabel != None:
            LOdoc.text.addElement(H(outlinelevel=1, stylename="Subtitle", text=tglabel))

        # insert text from comment subelement of testgroup element
        tgcommentel = tg.find("./comment")
        if tgcommentel != None:
            #print("commentel found")
            LOdoc.text.addElement(P(text=tgcommentel.text))

        tgbg = tg.get('background') # background attribute of testgroup element
        tablenum += 1
        table = Table(name="Table" + str(tablenum), stylename="Table1")
        table.addElement(TableColumn(stylename="Table1.A"))
        for n in range(numfonts):
            table.addElement(TableColumn(stylename="Table1.B"))
        table.addElement(TableColumn(stylename="Table1.A"))
        table.addElement(TableColumn(stylename="Table1.D"))
        for t in tg.findall("./test"):                # Each test element begins a new row
            # stuff to start the row
            labeltext = t.get('label')
            stylename = t.get('stylename')
            stringel = t.find('./string')
            commentel = t.find('./comment')
            rtlsuffix = "R" if t.get('rtl') == 'True' else ""
            comment = commentel.text if commentel != None else None
            colBstyle = "Table1.A1"
            tbg = t.get('background')   # get background attribute of test group (if one exists)
            if tbg == None: tbg = tgbg
            if tbg != None:             # if background attribute for test element (or background attribute for testgroup element)
                if tbg not in colordic: # if color not found in color dic, create new style
                    colorcount += 1
                    newname = basename + str(colorcount)
                    colordic[tbg] = newname
                    tb1style = Style(name=newname, family="table-cell")
                    tb1style.addElement(TableCellProperties(attributes={'padding':"0.0382in", 'border':"0.05pt solid #000000", 'backgroundcolor':tbg}))
                    LOdoc.automaticstyles.addElement(tb1style)
                colBstyle = colordic[tbg]

            row = TableRow()
            table.addElement(row)
            # fill cells
            # column A (label)
            cell = TableCell(stylename="Table1.A1", valuetype="string")
            if labeltext:
                cell.addElement(P(stylename="Table_20_Contents", text = labeltext))
            row.addElement(cell)

            # column B (string)
            for n in range(numfonts):
                Pnum = ftmlstyles[stylename] if stylename != None else "P2"
                Pnum = Pnum + formattedfontnum[n] + rtlsuffix
                ### not clear if any of the following can be moved outside loop and reused
                cell = TableCell(stylename=colBstyle, valuetype="string")
                par = P(stylename=Pnum)
                if len(stringel) == 0: # no <em> subelements
                    par.addText(re.sub(backu, hextounichr, stringel.text))
                else:   # handle <em> subelement(s)
                    if stringel.text != None:
                        par.addElement(Span(stylename="T1", text = re.sub(backu, hextounichr, stringel.text)))
                    for e in stringel.findall("em"):
                        if e.text != None:
                            par.addText(re.sub(backu, hextounichr, e.text))
                        if e.tail != None:
                            par.addElement(Span(stylename="T1", text = re.sub(backu, hextounichr, e.tail)))
                cell.addElement(par)
                row.addElement(cell)

            # column C (comment)
            cell = TableCell(stylename="Table1.A1", valuetype="string")
            if comment:
                cell.addElement(P(stylename="Table_20_Contents", text = comment))
            row.addElement(cell)

            # column D (stylename)
            cell = TableCell(stylename="Table1.A1", valuetype="string")
            if comment:
                cell.addElement(P(stylename="Table_20_Contents", text = stylename))
            row.addElement(cell)
        LOdoc.text.addElement(table)

    LOdoc.text.addElement(P(stylename="Subtitle", text="")) # Empty paragraph to end ### necessary?

    try:
        if fontstoembed: logfile.log("Embedding fonts in document", "V")
        for f in fontstoembed:
            LOdoc._extra.append(
                OpaqueObject(filename = "Fonts/" + os.path.basename(f),
                    mediatype = "application/x-font-ttf",      ### should be "application/font-woff" or "/font-woff2" for WOFF fonts, "/font-opentype" for ttf
                    content = io.open(f, "rb").read() ))
        ci = ConfigItem(**{'name':'EmbedFonts', 'type': 'boolean'}) ### (name = 'EmbedFonts', type = 'boolean')
        ci.addText('true')
        cis=ConfigItemSet(**{'name':'ooo:configuration-settings'})  ### (name = 'ooo:configuration-settings')
        cis.addElement(ci)
        LOdoc.settings.addElement(cis)
    except:
        logfile.log("Error embedding fonts in document", "E")
    logfile.log("Writing output file: " + args.output, "P")
    LOdoc.save(unicode(args.output))
    return
Esempio n. 57
0
    def to_ods(self, *selection):
        if not ODFLIB_INSTALLED:
            raise ODFLIBNotInstalled(_("odfpy not installed."))
        if self.fcn_list:
            stat_list = self.fcn_list[:]
            order_text = "   Ordered by: " + self.sort_type + "\n"
        else:
            stat_list = self.stats.keys()
            order_text = "   Random listing order was used\n"
        for s in selection:
            stat_list, __ = self.eval_print_amount(s, stat_list, "")
        spreadsheet = OpenDocumentSpreadsheet()
        table = Table(name="Profile")
        for fn in self.files:
            tcf = TableCell()
            tcf.addElement(P(text=fn))
            trf = TableRow()
            trf.addElement(tcf)
            table.addElement(trf)

        tc_summary = TableCell()
        summary_text = (
            "%d function calls (%d primitive calls) in %.6f \
                        seconds"
            % (self.total_calls, self.prim_calls, self.total_tt)
        )
        tc_summary.addElement(P(text=summary_text))
        tr_summary = TableRow()
        tr_summary.addElement(tc_summary)
        table.addElement(tr_summary)

        tc_order = TableCell()
        tc_order.addElement(P(text=order_text))
        tr_order = TableRow()
        tr_order.addElement(tc_order)
        table.addElement(tr_order)

        tr_header = TableRow()
        tc_cc = TableCell()
        tc_cc.addElement(P(text="Total Call Count"))
        tr_header.addElement(tc_cc)

        tc_pc = TableCell()
        tc_pc.addElement(P(text="Primitive Call Count"))
        tr_header.addElement(tc_pc)

        tc_tt = TableCell()
        tc_tt.addElement(P(text="Total Time(seconds)"))
        tr_header.addElement(tc_tt)

        tc_pc = TableCell()
        tc_pc.addElement(P(text="Time Per call(seconds)"))
        tr_header.addElement(tc_pc)

        tc_ct = TableCell()
        tc_ct.addElement(P(text="Cumulative Time(seconds)"))
        tr_header.addElement(tc_ct)

        tc_pt = TableCell()
        tc_pt.addElement(P(text="Cumulative Time per call(seconds)"))
        tr_header.addElement(tc_pt)

        tc_nfl = TableCell()
        tc_nfl.addElement(P(text="filename:lineno(function)"))
        tr_header.addElement(tc_nfl)

        table.addElement(tr_header)

        for func in stat_list:
            cc, nc, tt, ct, __ = self.stats[func]
            tr_header = TableRow()
            tc_nc = TableCell()
            tc_nc.addElement(P(text=nc))
            tr_header.addElement(tc_nc)

            tc_pc = TableCell()
            tc_pc.addElement(P(text=cc))
            tr_header.addElement(tc_pc)

            tc_tt = TableCell()
            tc_tt.addElement(P(text=tt))
            tr_header.addElement(tc_tt)

            tc_tpc = TableCell()
            tc_tpc.addElement(P(text=(None if nc == 0 else float(tt) / nc)))
            tr_header.addElement(tc_tpc)

            tc_ct = TableCell()
            tc_ct.addElement(P(text=ct))
            tr_header.addElement(tc_ct)

            tc_tpt = TableCell()
            tc_tpt.addElement(P(text=(None if cc == 0 else float(ct) / cc)))
            tr_header.addElement(tc_tpt)

            tc_nfl = TableCell()
            tc_nfl.addElement(P(text=func))
            tr_header.addElement(tc_nfl)
            table.addElement(tr_header)

        spreadsheet.spreadsheet.addElement(table)
        tmp_ods = tempfile.TemporaryFile()
        spreadsheet.write(tmp_ods)
        tmp_ods.seek(0)
        data = tmp_ods.read()
        os.close(tmp_ods)
        return data
Esempio n. 58
0
    def insert_table_(self,ar,column_names=None,table_width=180):
        ar.setup_from(self.ar)
        columns, headers, widths = ar.get_field_info(column_names)
        widths = map(int,widths)
        tw = sum(widths)
        """
        specifying relative widths doesn't seem to work
        (and that's a pity because absolute widths requires us 
        to know the table_width). 
        """
        use_relative_widths = False
        if use_relative_widths:
            width_specs = ["%d*" % (w*100/tw) for w in widths]
            #~ width_specs = [(w*100/tw) for w in widths]
        else:
            #~ total_width = 180 # suppose table width = 18cm = 180mm
            width_specs = ["%dmm" % (table_width*w/tw) for w in widths]
        #~ else:
            #~ width_specs = []
            #~ for w in widths:
				#~ if w.endswith('%'):
					#~ mm = float(w[:-1]) * table_width / 100
					#~ width_specs.append("%dmm" % mm)
				#~ else:
        #~ print 20120419, width_specs 
        
        doc = OpenDocumentText()
        
        def add_style(**kw):
            st = Style(**kw)
            doc.styles.addElement(st)
            self.my_styles.append(st)
            return st
            

        table_style_name = str(ar.actor)
        st = add_style(name=table_style_name, family="table",parentstylename="Default")
        st.addElement(TableProperties(align="margins", maybreakbetweenrows="0"))
        
        # create some *visible* styles
        
        st = add_style(name="Table Contents", family="paragraph",parentstylename="Default")
        st.addElement(ParagraphProperties(numberlines="false", 
            linenumber="0"))
            
        st = add_style(name="Number Cell", family="paragraph",parentstylename="Table Contents")
        st.addElement(ParagraphProperties(numberlines="false", 
            textalign="end", justifysingleword="true",
            linenumber="0"))
        
        dn = "Table Column Header"
        st = self.stylesManager.styles.getStyle(dn)
        if st is None:
            st = add_style(name=dn, family="paragraph",parentstylename="Table Contents")
            st.addElement(ParagraphProperties(numberlines="false", linenumber="0"))
            st.addElement(TextProperties(fontweight="bold"))
        
        dn = "Bold Text"
        st = self.stylesManager.styles.getStyle(dn)
        if st is None:
            st = add_style(name=dn, family="text",parentstylename="Default")
            #~ st = add_style(name=dn, family="text")
            st.addElement(TextProperties(fontweight="bold"))

        if False:
            dn = "L1"
            st = self.stylesManager.styles.getStyle(dn)
            if st is None:
                st = ListStyle(name=dn)
                doc.styles.addElement(st)
                p = ListLevelProperties(listlevelpositionandspacemode="label-alignment")
                st.addElement(p)
                #~ label-followed-by="listtab" text:list-tab-stop-position="1.27cm" fo:text-indent="-0.635cm" fo:margin-left="1.27cm"/>
                p.addElement(ListLevelLabelAlignment(labelfollowedby="listtab",
                    listtabstopposition="1.27cm",
                    textindent="-0.635cm",
                    marginleft="1.27cm"
                  ))
                self.my_styles.append(st)
                
                #~ list_style = add_style(name=dn, family="list")
                bullet = text.ListLevelStyleBullet(level=1,stylename="Bullet_20_Symbols",bulletchar=u"•")
                #~ bullet = text.ListLevelStyleBullet(level=1,stylename="Bullet_20_Symbols",bulletchar=u"*")
                #~ <text:list-level-style-bullet text:level="1" text:style-name="Bullet_20_Symbols" text:bullet-char="•">
                st.addElement(bullet)
        
        # create some automatic styles
        
        def add_style(**kw):
            st = Style(**kw)
            doc.automaticstyles.addElement(st)
            self.my_automaticstyles.append(st)
            return st
            
        cell_style = add_style(name="Lino Cell Style",family="table-cell")
        cell_style.addElement(TableCellProperties(
            paddingleft="1mm",paddingright="1mm",
            paddingtop="1mm",paddingbottom="0.5mm",
            border="0.002cm solid #000000"))
            
        header_row_style = add_style(name="Lino Header Row",family="table-row",parentstylename=cell_style)
        header_row_style.addElement(TableRowProperties(backgroundcolor="#eeeeee"))
        
        total_row_style = add_style(name="Lino Total Row",family="table-row",parentstylename=cell_style)
        total_row_style.addElement(TableRowProperties(backgroundcolor="#ffffff"))
        
        table = Table(name=table_style_name,stylename=table_style_name)
        table_columns = TableColumns()
        table.addElement(table_columns)
        table_header_rows = TableHeaderRows()
        table.addElement(table_header_rows)
        table_rows = TableRows()
        table.addElement(table_rows)
        
        # create table columns and automatic table-column styles 
        for i,fld in enumerate(columns):
            #~ print 20120415, repr(fld.name)
            name = str(ar.actor)+"."+fld.name
            cs = add_style(name=name, family="table-column")
            if use_relative_widths:
                cs.addElement(TableColumnProperties(relcolumnwidth=width_specs[i]))
            else:
                cs.addElement(TableColumnProperties(columnwidth=width_specs[i]))
            #~ cs.addElement(TableColumnProperties(useoptimalcolumnwidth='true'))
            #~ k = cs.getAttribute('name')
            #~ renderer.stylesManager.styles[k] = toxml(e)
            #~ doc.automaticstyles.addElement(cs)
            #~ self.my_automaticstyles.append(cs)
            table_columns.addElement(TableColumn(stylename=name))
            
        from lino.ui import elems
        def fldstyle(fld):
            #~ if isinstance(fld,ext_store.VirtStoreField):
                #~ fld = fld.delegate
            if isinstance(fld,elems.NumberFieldElement):
                return "Number Cell"
            return "Table Contents"
        
        def value2cell(ar,i,fld,val,style_name,tc):
            #~ text = html2odt.html2odt(fld.value2html(ar,val))
            params = dict()
            #~ if isinstance(fld,ext_store.BooleanStoreField):
                #~ params.update(text=fld.value2html(ar,val))
            #~ else:
                #~ params.update(text=fld.format_value(ar,val))
            #~ params.update(text=fld.format_value(ar,val))
            txt = fld.value2html(ar,val)
            
            p = text.P(stylename=style_name)
            html2odf(txt,p)
            
            try:
                tc.addElement(p)
            except Exception as e:
                logger.warning("20120614 addElement %s %s %r : %s", i, fld, val, e)
                #~ print 20120614, i, fld, val, e
                
            #~ yield P(stylename=tablecontents,text=text)
            
        # create header row
        #~ hr = TableRow(stylename=HEADER_ROW_STYLE_NAME)
        hr = TableRow(stylename=header_row_style)
        table_header_rows.addElement(hr)
        for h in headers:
        #~ for fld in fields:
            #~ tc = TableCell(stylename=CELL_STYLE_NAME)
            tc = TableCell(stylename=cell_style)
            tc.addElement(text.P(
                stylename="Table Column Header",
                #~ text=force_unicode(fld.field.verbose_name or fld.name)))
                text=force_unicode(h)))
            hr.addElement(tc)
            
        sums  = [fld.zero for fld in columns]
          
        for row in ar.data_iterator:
            #~ for grp in ar.group_headers(row):
                #~ raise NotImplementedError()
            tr = TableRow()
            
            has_numeric_value = False
            
            for i,fld in enumerate(columns):
                #~ tc = TableCell(stylename=CELL_STYLE_NAME)
                tc = TableCell(stylename=cell_style)
                #~ if fld.field is not None:
                v = fld.field._lino_atomizer.full_value_from_object(row,ar)
                stylename = fldstyle(fld)
                if v is None:
                    tc.addElement(text.P(stylename=stylename,text=''))
                else:
                    value2cell(ar,i,fld,v,stylename,tc)
                    
                    
                    nv = fld.value2num(v)
                    if nv != 0:
                        sums[i] += nv
                        has_numeric_value = True
                    #~ sums[i] += fld.value2num(v)
                tr.addElement(tc)
            
            if has_numeric_value or not ar.actor.hide_zero_rows:
                table_rows.addElement(tr)
                
        if not ar.actor.hide_sums:
            if sums != [fld.zero for fld in columns]:
                tr = TableRow(stylename=total_row_style)
                table_rows.addElement(tr)
                for i,fld in enumerate(columns):
                    tc = TableCell(stylename=cell_style)
                    stylename = fldstyle(fld)
                    p = text.P(stylename=stylename)
                    e = fld.format_sum(ar,sums,i)
                    html2odf(e,p)
                    tc.addElement(p)
                    #~ if len(txt) != 0: 
                        #~ msg = "html2odf() returned "
                        #~ logger.warning(msg)
                    #~ txt = tuple(html2odf(fld.format_sum(ar,sums,i),p))
                    #~ assert len(txt) == 1
                    #~ tc.addElement(text.P(stylename=stylename,text=txt[0]))
                    tr.addElement(tc)
            

        doc.text.addElement(table)
        return toxml(table)
Esempio n. 59
0
File: views.py Progetto: zxdvd/snoek
def _toODSTable(v_table):
    # generate an ods file to download
    # input: Object VoteTable
    # output: Object ods.table

    table= Table(name=v_table.title)

    row_head = v_table.row_head
    col_head = v_table.col_head
    table_body = v_table.table_body

    # Render column head if it is a 2D table
    if v_table.is2D():
        table.name = '2D'
        tr= TableRow()
        table.addElement(tr)
        td= TableCell()
        td.addElement(P(text='Head'))
        tr.addElement(td)
        for headcell in v_table.col_head:
            td= TableCell()
            td.addElement(P(text=headcell.content))
            tr.addElement(td)

    for cursorRow in v_table.table_with_row:
        tr= TableRow()
        table.addElement(tr)
        td= TableCell()
        td.addElement(P(text=cursorRow['row_head'].content))
        tr.addElement(td)

        for val in cursorRow['row_body']:
            td= TableCell()
            td.addElement(P(text=val))
            tr.addElement(td)

    #myFile= tempfile.TemporaryFile('/tmp/')
    #doc.save('/tmp/test', True)
    return table