FM / odf3

/usr/lib/python2.6/site-packages/tablib/packages/odf3/

/usr/lib/python2.6/site-packages/tablib/packages/odf3

Name	Size	Mode	Actions
anim.py	1872	0644	edit dl rm
anim.pyc	2724	0644	edit dl rm
attrconverters.py	68210	0644	edit dl rm
attrconverters.pyc	57355	0644	edit dl rm
chart.py	2636	0644	edit dl rm
chart.pyc	4624	0644	edit dl rm
config.py	1420	0644	edit dl rm
config.pyc	1391	0644	edit dl rm
dc.py	2225	0644	edit dl rm
dc.pyc	1464	0644	edit dl rm
dr3d.py	1448	0644	edit dl rm
dr3d.pyc	1524	0644	edit dl rm
draw.py	5590	0644	edit dl rm
draw.pyc	10343	0644	edit dl rm
easyliststyle.py	3773	0644	edit dl rm
easyliststyle.pyc	2312	0644	edit dl rm
element.py	20473	0755	edit dl rm
element.pyc	22250	0644	edit dl rm
elementtypes.py	9933	0755	edit dl rm
elementtypes.pyc	8729	0644	edit dl rm
form.py	3270	0644	edit dl rm
form.pyc	6390	0644	edit dl rm
grammar.py	193388	0644	edit dl rm
grammar.pyc	106458	0644	edit dl rm
load.py	3963	0755	edit dl rm
load.pyc	3409	0644	edit dl rm
manifest.py	1389	0755	edit dl rm
manifest.pyc	1344	0644	edit dl rm
math.py	1068	0644	edit dl rm
math.pyc	459	0644	edit dl rm
meta.py	2138	0644	edit dl rm
meta.pyc	3243	0644	edit dl rm
namespaces.py	3943	0644	edit dl rm
namespaces.pyc	3314	0644	edit dl rm
number.py	3137	0644	edit dl rm
number.pyc	5743	0644	edit dl rm
odf2moinmoin.py	18192	0644	edit dl rm
odf2moinmoin.pyc	18774	0644	edit dl rm
odf2xhtml.py	65058	0755	edit dl rm
odf2xhtml.pyc	64620	0644	edit dl rm
odfmanifest.py	3570	0755	edit dl rm
odfmanifest.pyc	4072	0644	edit dl rm
office.py	3346	0644	edit dl rm
office.pyc	5895	0644	edit dl rm
opendocument.py	25907	0644	edit dl rm
opendocument.pyc	25530	0644	edit dl rm
presentation.py	2716	0644	edit dl rm
presentation.pyc	4555	0644	edit dl rm
script.py	1106	0644	edit dl rm
script.pyc	484	0644	edit dl rm
style.py	4672	0644	edit dl rm
style.pyc	9062	0644	edit dl rm
svg.py	1790	0644	edit dl rm
svg.pyc	2406	0644	edit dl rm
table.py	9408	0644	edit dl rm
table.pyc	20593	0644	edit dl rm
teletype.py	5181	0644	edit dl rm
teletype.pyc	4460	0644	edit dl rm
text.py	17215	0644	edit dl rm
text.pyc	39126	0644	edit dl rm
thumbnail.py	31736	0755	edit dl rm
thumbnail.pyc	31864	0644	edit dl rm
userfield.py	5394	0755	edit dl rm
userfield.pyc	5159	0644	edit dl rm
xforms.py	1233	0644	edit dl rm
xforms.pyc	873	0644	edit dl rm
__init__.py	0	0644	edit dl rm
__init__.pyc	148	0644	edit dl rm

Edit: /usr/lib/python2.6/site-packages/tablib/packages/odf3/odf2moinmoin.py (18192B)

# -*- coding: utf-8 -*-
# Copyright (C) 2006-2008 Søren Roug, European Environment Agency
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
#
# See http://trac.edgewall.org/wiki/WikiFormatting
#
# Contributor(s):
#

import sys, zipfile, xml.dom.minidom
from .namespaces import nsdict
from .elementtypes import *

IGNORED_TAGS = [
    'draw:a'
    'draw:g',
    'draw:line',
    'draw:object-ole',
    'office:annotation',
    'presentation:notes',
    'svg:desc',
] + [ nsdict[item[0]]+":"+item[1] for item in empty_elements]

INLINE_TAGS = [ nsdict[item[0]]+":"+item[1] for item in inline_elements]

class TextProps:
    """ Holds properties for a text style. """

def __init__(self):

self.italic = False
        self.bold = False
        self.fixed = False
        self.underlined = False
        self.strikethrough = False
        self.superscript = False
        self.subscript = False

def setItalic(self, value):
        if value == "italic":
            self.italic = True
        elif value == "normal":
            self.italic = False

def setBold(self, value):
        if value == "bold":
            self.bold = True
        elif value == "normal":
            self.bold = False

def setFixed(self, value):
        self.fixed = value

def setUnderlined(self, value):
        if value and value != "none":
            self.underlined = True

def setStrikethrough(self, value):
        if value and value != "none":
            self.strikethrough = True

def setPosition(self, value):
        if value is None or value == '':
            return
        posisize = value.split(' ')
        textpos = posisize[0]
        if textpos.find('%') == -1:
            if textpos == "sub":
                self.superscript = False
                self.subscript = True
            elif textpos == "super":
                self.superscript = True
                self.subscript = False
        else:
            itextpos = int(textpos[:textpos.find('%')])
            if itextpos > 10:
                self.superscript = False
                self.subscript = True
            elif itextpos < -10:
                self.superscript = True
                self.subscript = False

def __str__(self):

return "[italic=%s, bold=i%s, fixed=%s]" % (str(self.italic),
                                          str(self.bold),
                                          str(self.fixed))

class ParagraphProps:
    """ Holds properties of a paragraph style. """

def __init__(self):

self.blockquote = False
        self.headingLevel = 0
        self.code = False
        self.title = False
        self.indented = 0

def setIndented(self, value):
        self.indented = value

def setHeading(self, level):
        self.headingLevel = level

def setTitle(self, value):
        self.title = value

def setCode(self, value):
        self.code = value

def __str__(self):

return "[bq=%s, h=%d, code=%s]" % (str(self.blockquote),
                                           self.headingLevel,
                                           str(self.code))

class ListProperties:
    """ Holds properties for a list style. """

def __init__(self):
        self.ordered = False

def setOrdered(self, value):
        self.ordered = value

class ODF2MoinMoin(object):

def __init__(self, filepath):
        self.footnotes = []
        self.footnoteCounter = 0
        self.textStyles = {"Standard": TextProps()}
        self.paragraphStyles = {"Standard": ParagraphProps()}
        self.listStyles = {}
        self.fixedFonts = []
        self.hasTitle = 0
        self.lastsegment = None

# Tags
        self.elements = {
         'draw:page': self.textToString,
         'draw:frame': self.textToString,
         'draw:image': self.draw_image,
         'draw:text-box': self.textToString,
         'text:a': self.text_a,
         'text:note': self.text_note,
        }
        for tag in IGNORED_TAGS:
            self.elements[tag] = self.do_nothing

for tag in INLINE_TAGS:
            self.elements[tag] = self.inline_markup
        self.elements['text:line-break'] = self.text_line_break
        self.elements['text:s'] = self.text_s
        self.elements['text:tab'] = self.text_tab

self.load(filepath)

def processFontDeclarations(self, fontDecl):
        """ Extracts necessary font information from a font-declaration
            element.
            """
        for fontFace in fontDecl.getElementsByTagName("style:font-face"):
            if fontFace.getAttribute("style:font-pitch") == "fixed":
                self.fixedFonts.append(fontFace.getAttribute("style:name"))

def extractTextProperties(self, style, parent=None):
        """ Extracts text properties from a style element. """

textProps = TextProps()

if parent:
            parentProp = self.textStyles.get(parent, None)
            if parentProp:
                textProp = parentProp

textPropEl = style.getElementsByTagName("style:text-properties")
        if not textPropEl: return textProps

textPropEl = textPropEl[0]

textProps.setItalic(textPropEl.getAttribute("fo:font-style"))
        textProps.setBold(textPropEl.getAttribute("fo:font-weight"))
        textProps.setUnderlined(textPropEl.getAttribute("style:text-underline-style"))
        textProps.setStrikethrough(textPropEl.getAttribute("style:text-line-through-style"))
        textProps.setPosition(textPropEl.getAttribute("style:text-position"))

if textPropEl.getAttribute("style:font-name") in self.fixedFonts:
            textProps.setFixed(True)

return textProps

def extractParagraphProperties(self, style, parent=None):
        """ Extracts paragraph properties from a style element. """

paraProps = ParagraphProps()

name = style.getAttribute("style:name")

if name.startswith("Heading_20_"):
            level = name[11:]
            try:
                level = int(level)
                paraProps.setHeading(level)
            except:
                level = 0

if name == "Title":
            paraProps.setTitle(True)

paraPropEl = style.getElementsByTagName("style:paragraph-properties")
        if paraPropEl:
            paraPropEl = paraPropEl[0]
            leftMargin = paraPropEl.getAttribute("fo:margin-left")
            if leftMargin:
                try:
                    leftMargin = float(leftMargin[:-2])
                    if leftMargin > 0.01:
                        paraProps.setIndented(True)
                except:
                    pass

textProps = self.extractTextProperties(style)
        if textProps.fixed:
            paraProps.setCode(True)

return paraProps

def processStyles(self, styleElements):
        """ Runs through "style" elements extracting necessary information.
        """

for style in styleElements:

name = style.getAttribute("style:name")

if name == "Standard": continue

family = style.getAttribute("style:family")
            parent = style.getAttribute("style:parent-style-name")

if family == "text":
                self.textStyles[name] = self.extractTextProperties(style, parent)

elif family == "paragraph":
                self.paragraphStyles[name] = \
                                 self.extractParagraphProperties(style, parent)
                self.textStyles[name] = self.extractTextProperties(style, parent)

def processListStyles(self, listStyleElements):

for style in listStyleElements:
            name = style.getAttribute("style:name")

prop = ListProperties()
            if style.hasChildNodes():
                subitems = [el for el in style.childNodes
                     if el.nodeType == xml.dom.Node.ELEMENT_NODE
                     and el.tagName == "text:list-level-style-number"]
                if len(subitems) > 0:
                    prop.setOrdered(True)

self.listStyles[name] = prop

def load(self, filepath):
        """ Loads an ODT file. """

zip = zipfile.ZipFile(filepath)

styles_doc = xml.dom.minidom.parseString(zip.read("styles.xml"))
        fontfacedecls = styles_doc.getElementsByTagName("office:font-face-decls")
        if fontfacedecls:
            self.processFontDeclarations(fontfacedecls[0])
        self.processStyles(styles_doc.getElementsByTagName("style:style"))
        self.processListStyles(styles_doc.getElementsByTagName("text:list-style"))

self.content = xml.dom.minidom.parseString(zip.read("content.xml"))
        fontfacedecls = self.content.getElementsByTagName("office:font-face-decls")
        if fontfacedecls:
            self.processFontDeclarations(fontfacedecls[0])

self.processStyles(self.content.getElementsByTagName("style:style"))
        self.processListStyles(self.content.getElementsByTagName("text:list-style"))

def compressCodeBlocks(self, text):
        """ Removes extra blank lines from code blocks. """

return text
        lines = text.split("\n")
        buffer = []
        numLines = len(lines)
        for i in range(numLines):

if (lines[i].strip() or i == numLines-1  or i == 0 or
                not ( lines[i-1].startswith("    ")
                      and lines[i+1].startswith("    ") ) ):
                buffer.append("\n" + lines[i])

return ''.join(buffer)

#-----------------------------------
    def do_nothing(self, node):
        return ''

def draw_image(self, node):
        """
        """

link = node.getAttribute("xlink:href")
        if link and link[:2] == './': # Indicates a sub-object, which isn't supported
            return "%s\n" % link
        if link and link[:9] == 'Pictures/':
            link = link[9:]
        return "[[Image(%s)]]\n" % link

def text_a(self, node):
        text = self.textToString(node)
        link = node.getAttribute("xlink:href")
        if link.strip() == text.strip():
            return "[%s] " % link.strip()
        else:
            return "[%s %s] " % (link.strip(), text.strip())

def text_line_break(self, node):
        return "[[BR]]"

def text_note(self, node):
        cite = (node.getElementsByTagName("text:note-citation")[0]
                    .childNodes[0].nodeValue)
        body = (node.getElementsByTagName("text:note-body")[0]
                    .childNodes[0])
        self.footnotes.append((cite, self.textToString(body)))
        return "^%s^" % cite

def text_s(self, node):
        try:
            num = int(node.getAttribute("text:c"))
            return " "*num
        except:
            return " "

def text_tab(self, node):
        return "    "

def inline_markup(self, node):
        text = self.textToString(node)

if not text.strip():
            return ''  # don't apply styles to white space

styleName = node.getAttribute("text:style-name")
        style = self.textStyles.get(styleName, TextProps())

if style.fixed:
            return "`" + text + "`"

mark = []
        if style:
            if style.italic:
                mark.append("''")
            if style.bold:
                mark.append("'''")
            if style.underlined:
                mark.append("__")
            if style.strikethrough:
                mark.append("~~")
            if style.superscript:
                mark.append("^")
            if style.subscript:
                mark.append(",,")
        revmark = mark[:]
        revmark.reverse()
        return "%s%s%s" % (''.join(mark), text, ''.join(revmark))

#-----------------------------------
    def listToString(self, listElement, indent = 0):

self.lastsegment = listElement.tagName
        buffer = []

styleName = listElement.getAttribute("text:style-name")
        props = self.listStyles.get(styleName, ListProperties())

i = 0
        for item in listElement.childNodes:
            buffer.append(" "*indent)
            i += 1
            if props.ordered:
                number = str(i)
                number = " " + number + ". "
                buffer.append(" 1. ")
            else:
                buffer.append(" * ")
            subitems = [el for el in item.childNodes
                          if el.tagName in ["text:p", "text:h", "text:list"]]
            for subitem in subitems:
                if subitem.tagName == "text:list":
                    buffer.append("\n")
                    buffer.append(self.listToString(subitem, indent+3))
                else:
                    buffer.append(self.paragraphToString(subitem, indent+3))
                self.lastsegment = subitem.tagName
            self.lastsegment = item.tagName
            buffer.append("\n")

return ''.join(buffer)

def tableToString(self, tableElement):
        """ MoinMoin uses || to delimit table cells
        """

self.lastsegment = tableElement.tagName
        buffer = []

for item in tableElement.childNodes:
            self.lastsegment = item.tagName
            if item.tagName == "table:table-header-rows":
                buffer.append(self.tableToString(item))
            if item.tagName == "table:table-row":
                buffer.append("\n||")
                for cell in item.childNodes:
                    buffer.append(self.inline_markup(cell))
                    buffer.append("||")
                    self.lastsegment = cell.tagName
        return ''.join(buffer)

def toString(self):
        """ Converts the document to a string.
            FIXME: Result from second call differs from first call
        """
        body = self.content.getElementsByTagName("office:body")[0]
        text = body.childNodes[0]

buffer = []

paragraphs = [el for el in text.childNodes
                      if el.tagName in ["draw:page", "text:p", "text:h","text:section",
                                        "text:list", "table:table"]]

for paragraph in paragraphs:
            if paragraph.tagName == "text:list":
                text = self.listToString(paragraph)
            elif paragraph.tagName == "text:section":
                text = self.textToString(paragraph)
            elif paragraph.tagName == "table:table":
                text = self.tableToString(paragraph)
            else:
                text = self.paragraphToString(paragraph)
            if text:
                buffer.append(text)

if self.footnotes:

buffer.append("----")
            for cite, body in self.footnotes:
                buffer.append("%s: %s" % (cite, body))

buffer.append("")
        return self.compressCodeBlocks('\n'.join(buffer))

def textToString(self, element):

buffer = []

for node in element.childNodes:

if node.nodeType == xml.dom.Node.TEXT_NODE:
                buffer.append(node.nodeValue)

elif node.nodeType == xml.dom.Node.ELEMENT_NODE:
                tag = node.tagName

if tag in ("draw:text-box", "draw:frame"):
                    buffer.append(self.textToString(node))

elif tag in ("text:p", "text:h"):
                    text = self.paragraphToString(node)
                    if text:
                        buffer.append(text)
                elif tag == "text:list":
                    buffer.append(self.listToString(node))
                else:
                    method = self.elements.get(tag)
                    if method:
                        buffer.append(method(node))
                    else:
                        buffer.append(" {" + tag + "} ")

return ''.join(buffer)

def paragraphToString(self, paragraph, indent = 0):

dummyParaProps = ParagraphProps()

style_name = paragraph.getAttribute("text:style-name")
        paraProps = self.paragraphStyles.get(style_name, dummyParaProps)
        text = self.inline_markup(paragraph)

if paraProps and not paraProps.code:
            text = text.strip()

if paragraph.tagName == "text:p" and self.lastsegment == "text:p":
            text = "\n" + text

self.lastsegment = paragraph.tagName

if paraProps.title:
            self.hasTitle = 1
            return "= " + text + " =\n"

outlinelevel = paragraph.getAttribute("text:outline-level")
        if outlinelevel:

level = int(outlinelevel)
            if self.hasTitle: level += 1

if level >= 1:
                return "=" * level + " " + text + " " + "=" * level + "\n"

elif paraProps.code:
            return "{{{\n" + text + "\n}}}\n"

if paraProps.indented:
            return self.wrapParagraph(text, indent = indent, blockquote = True)

else:
            return self.wrapParagraph(text, indent = indent)

def wrapParagraph(self, text, indent = 0, blockquote=False):

counter = 0
        buffer = []
        LIMIT = 50

if blockquote:
            buffer.append("  ")

return ''.join(buffer) + text
        # Unused from here
        for token in text.split():

if counter > LIMIT - indent:
                buffer.append("\n" + " "*indent)
                if blockquote:
                    buffer.append("  ")
                counter = 0

buffer.append(token + " ")
            counter += len(token)

return ''.join(buffer)

cmd: