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.


One Click, Universal Protection: Implementing Centralized Security Policies on Linux Systems

As Linux continues to play an ever increasing role in corporate data centers and institutions, ensuring the integrity and protection of these systems must be a priority. With 60% of the world's websites and an increasing share of organization's mission-critical workloads running on Linux, failing to stop malware and other advanced threats on Linux can increasingly impact an organization's reputation and bottom line.

Learn More

Sponsored by Bit9

Linux Backup and Recovery Webinar

Most companies incorporate backup procedures for critical data, which can be restored quickly if a loss occurs. However, fewer companies are prepared for catastrophic system failures, in which they lose all data, the entire operating system, applications, settings, patches and more, reducing their system(s) to “bare metal.” After all, before data can be restored to a system, there must be a system to restore it to.

In this one hour webinar, learn how to enhance your existing backup strategies for better disaster recovery preparedness using Storix System Backup Administrator (SBAdmin), a highly flexible bare-metal recovery solution for UNIX and Linux systems.

Learn More

Sponsored by Storix