ODF, Python and XML

Combine Python with the open format of ODF files to manipulate fine details. Writer showed what we expected. Both the double hyphen and the en dash changed into em dashes, and the starting double quote curves the right way.

Now, here's the rest. The expression to deal with the ending double quote is the mirror image of the starting double quote. In order to write an ending/closing double quote, we require the quote character either to be at the end of the string (\Z) or followed by whitespace. Again, when we do the replacement, we want to replace only the quote itself, not the whitespace. Hence, the Ending Double-quote PATtern (eDpat) is given by:

eDpat = re.compile(r'("\Z)|("(?=\s))', re.U)

By the way, we compile all these patterns because we're going to use them over and over again when processing documents.

To handle single quotes ('like these'), we basically can do the same thing, except for a couple of issues. First, is the problem of contractions. When handling a double-quote character, we didn't cover the case where it was surrounded on both sides by non-whitespace. With single quotes (or apostrophes), we can't avoid that, because of words such as can't. Therefore, although the starting single-quote pattern can match the starting double-quote pattern, the other one, which doubles as an apostrophe in contractions, has a looser pattern. Here's what I came up with:

eSpat = re.compile(r"(?<=\S)'", re.U)

Because the pattern has an apostrophe in it, we delimit the pattern string using double-quote characters. This expression matches a single quote, but only when preceded immediately by a non-whitespace character.

The second issue, which the code doesn't address, is that of contractions beginning with an apostrophe, such as 'tis the season or stick 'em up.

The script treats the leading apostrophe like the start of a single-quoted phrase, and the single quote will face the wrong way. This probably will need a manual work-around.

Putting all this together, we have

#!/usr/bin/python -tt
import xml.dom.minidom
import sys
import re                 # new in

def dprint(what):
   if DEBUG == 0: return
                                'replace') + '\n')

enDash=u'\u2013'          # new in
sDquote=u'\u201c'         # new in
eDquote=u'\u201d'         # new in
sSquote=u'\u2018'         # new in
eSquote=u'\u2019'         # new in

# sDpat: pattern for starting dbl quote, as
#        "Go! <-- the quote there
#        We look for it either at start (\A) or
#        after a space (\s), and we want it to be
#        followed by a non-space
sDpat = re.compile(r'(\A|(?<=\s))"(?=\S)', re.U)  # new in
eDpat = re.compile(r'("\Z)|("(?=\s))', re.U)      # new in
sSpat = re.compile(r"(\A|(?<=\s))'(?=\S)", re.U)  # new in
eSpat = re.compile(r"(?<=\S)'", re.U)             # new in

def fixdata(td, depth):
   dprint("depth=%d: childNode: %s" %
   # OK, so '--' becomes em dash everywhere ='--', emDash)
   # Change 'en' dash to 'em' dash = , emDash)   # new in
   # Make a nice starting curly-quote           # new in = sDpat.sub(sDquote,        # new in = eDpat.sub(eDquote,        # new in
   # Make nice curly single-quote characters = sSpat.sub(sSquote,        # new in = eSpat.sub(eSquote,        # new in

def handle_xml_tree(aNode, depth):
   if aNode.hasChildNodes():
      for kid in aNode.childNodes:
         handle_xml_tree(kid, depth+1)
      if 'data' in dir(aNode):
         fixdata(aNode, depth)

def doit(argv):
   doc = xml.dom.minidom.parse(argv[1])
   handle_xml_tree(doc, 0)

if __name__ == "__main__":

Let's try that on our example:

% ln -sf
% ./ ex3.odt ex3-4.odt
depth=5: childNode: The ?en? dash ? is too short
depth=5: childNode: The ?em? dash ? which is
 longer ? is what we need.
depth=5: childNode: And two hyphens -- ugly -- should
 be turned into ?em? dashes.
depth=5: childNode: This line has "straight
 double quotes"
depth=5: childNode: These 'single quotes'
 aren't pretty.
% oowriter ex3-4.odt

Figure 10. Python string handling gets results.

Let's review what we've done here:

  • Wrote scripts to unpack and repack ODF files.

  • Learned about using Python to understand the structure of ODF files.

  • Wrote a Python program to perform useful transformations on an Writer file, using regular expressions and the built-in string methods.