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.


White Paper
Linux Management with Red Hat Satellite: Measuring Business Impact and ROI

Linux has become a key foundation for supporting today's rapidly growing IT environments. Linux is being used to deploy business applications and databases, trading on its reputation as a low-cost operating environment. For many IT organizations, Linux is a mainstay for deploying Web servers and has evolved from handling basic file, print, and utility workloads to running mission-critical applications and databases, physically, virtually, and in the cloud. As Linux grows in importance in terms of value to the business, managing Linux environments to high standards of service quality — availability, security, and performance — becomes an essential requirement for business success.

Learn More

Sponsored by Red Hat

White Paper
Private PaaS for the Agile Enterprise

If you already use virtualized infrastructure, you are well on your way to leveraging the power of the cloud. Virtualization offers the promise of limitless resources, but how do you manage that scalability when your DevOps team doesn’t scale? In today’s hypercompetitive markets, fast results can make a difference between leading the pack vs. obsolescence. Organizations need more benefits from cloud computing than just raw resources. They need agility, flexibility, convenience, ROI, and control.

Stackato private Platform-as-a-Service technology from ActiveState extends your private cloud infrastructure by creating a private PaaS to provide on-demand availability, flexibility, control, and ultimately, faster time-to-market for your enterprise.

Learn More

Sponsored by ActiveState