Starting, Stopping, and Connecting to OpenOffice with Python


Using pyuno you can script OpenOffice with Python. Pyuno allows you to create macros inside OpenOffice and it also allows you to create external Python scripts that talk to a running copy of OpenOffice. If you want to get started with pyuno be prepared for an often frustrating experience: the documentation is sketchy and often just plain hard to locate, and the version of Python that's embedded in OpenOffice has been stuck at version 2.3 for quite a while now.

Pyuno is the Python layer that implements OpenOffice's UNO interface. UNO is an application programming language independent interface to OpenOffice. UNO is specified in IDL and often the only documentation for pyuno is the IDL documentation for UNO.

The code presented here runs outside of OpenOffice and shows how to start, stop, and connect to OpenOffice in "headless" mode. Running OpenOffice in "headless" mode means that OpenOffice doesn't display a window it just waits for UNO operations (via a TCP/IP port). The code presented here was tested with version 2.5 of Python and version 2.4 of OpenOffice. I also tested it with version 3.0 of OpenOffice but it only runs if you use the version of Python that comes with OpenOffice.

The code consists mainly of the Python class OORunner which has methods for connecting to OpenOffice, for starting it, and for shutting it down. The code also keeps track of all the copies of OpenOffice that it's started and shuts them all down on exit. This code is based on some code that I found here, I refactored the connecting and added the ability to start and and stop OpenOffice from Python. The file name is

# OpenOffice utils.
# Based on code from:
#   PyODConverter (Python OpenDocument Converter) v1.0.0 - 2008-05-05
#   Copyright (C) 2008 Mirko Nasato <>
#   Licensed under the GNU LGPL v2.1 - or any later version.

import sys
import os
import time
import atexit


# Find OpenOffice.
        ('/usr/lib64/ooo-2.0/program',   '/usr/lib64/ooo-2.0/program'),
        ('/opt/openoffice.org3/program', '/opt/'),

for p in _oopaths:
    if os.path.exists(p[0]):
        OPENOFFICE_PATH    = p[0]
        OPENOFFICE_BIN     = os.path.join(OPENOFFICE_PATH, 'soffice')

        # Add to path so we can find uno.
        if sys.path.count(OPENOFFICE_LIBPATH) == 0:
            sys.path.insert(0, OPENOFFICE_LIBPATH)

import uno
from import PropertyValue
from import NoConnectException

class OORunner:
    Start, stop, and connect to OpenOffice.
    def __init__(self, port=OPENOFFICE_PORT):
        """ Create OORunner that connects on the specified port. """
        self.port = port

    def connect(self, no_startup=False):
        Connect to OpenOffice.
        If a connection cannot be established try to start OpenOffice.
        localContext = uno.getComponentContext()
        resolver     = localContext.ServiceManager.createInstanceWithContext("", localContext)
        context      = None
        did_start    = False

        n = 0
        while n < 6:
                context = resolver.resolve("uno:socket,host=localhost,port=%d;urp;StarOffice.ComponentContext" % self.port)
            except NoConnectException:

            # If first connect failed then try starting OpenOffice.
            if n == 0:
                # Exit loop if startup not desired.
                if no_startup:
                did_start = True

            # Pause and try again to connect
            n += 1

        if not context:
            raise Exception, "Failed to connect to OpenOffice on port %d" % self.port

        desktop = context.ServiceManager.createInstanceWithContext("", context)

        if not desktop:
            raise Exception, "Failed to create OpenOffice desktop on port %d" % self.port

        if did_start:
            _started_desktops[self.port] = desktop

        return desktop

    def startup(self):
        Start a headless instance of OpenOffice.
        args = [OPENOFFICE_BIN,
                '-accept=socket,host=localhost,port=%d;urp;StarOffice.ServiceManager' % self.port,
        env  = {'PATH'       : '/bin:/usr/bin:%s' % OPENOFFICE_PATH,

            pid = os.spawnve(os.P_NOWAIT, args[0], args, env)
        except Exception, e:
            raise Exception, "Failed to start OpenOffice on port %d: %s" % (self.port, e.message)

        if pid <= 0:
            raise Exception, "Failed to start OpenOffice on port %d" % self.port

    def shutdown(self):
        Shutdown OpenOffice.
            if _started_desktops.get(self.port):
                del _started_desktops[self.port]
        except Exception, e:

# Keep track of started desktops and shut them down on exit.
_started_desktops = {}

def _shutdown_desktops():
    """ Shutdown all OpenOffice desktops that were started by the program. """
    for port, desktop in _started_desktops.items():
            if desktop:
        except Exception, e:


def oo_shutdown_if_running(port=OPENOFFICE_PORT):
    """ Shutdown OpenOffice if it's running on the specified port. """
    oorunner = OORunner(port)
        desktop = oorunner.connect(no_startup=True)
    except Exception, e:

def oo_properties(**args):
    Convert args to OpenOffice property values.
    props = []
    for key in args:
        prop       = PropertyValue()
        prop.Name  = key
        prop.Value = args[key]

    return tuple(props)

Using the class is straightforward: you simply create an instance of it and call connect() on that instance. Connect returns the OpenOffice desktop object. This is the object that you use for most interactions with OpenOffice.

   oor     = ooutils.OORunner()
   desktop = oor.connect()
   # Do something with the "desktop"

As I mentioned there are also startup and shutdown methods, but you don't really need to call them: the connect method will call the startup method if it's unable to connect and the atexit code will shutdown all started copies of OpenOffice on exit. There's also a function oo_shutdown_if_running() that can be called to shutdown a desktop if it's running.

Next week I'll show you how to use the code presented here to write a Python program to convert spreadsheets to CSV files.


Mitch Frazier is an Associate Editor for Linux Journal.


Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.


Adrián Cereto Massagué's picture

That's a great module! I was looking for how to start/stop OO.o from python for an app i'm doing i find your module as a great start point for my project.

And then arrived at the point that i've noticed you said nothing about license to use your module.

So just in case i'm asking here ;)
It would be nice if i could develop a gpl'ed app starting from your module (as it would need some modifications in order to fit my needs)

So what can be done with it? what kind of license it's under? lgpl, gpl, cc, bsd , public domain ...?

Public Domain

Mitch Frazier's picture

Use it however you like, as long as it doesn't violate the license terms of the code it's based on (see the top of the code).

Mitch Frazier is an Associate Editor for Linux Journal.

Long lines

Anonymous's picture

It's nice, indeed, but could I suggest not to write lines longer than 80 characters in the Python code.
The longest line is 131 characters; and my browser does not show the end of these long lines.

I think we need a web site fix

Mitch Frazier's picture

The site should be putting that in a scroll box, I'll have to check with the webmaster.

Mitch Frazier is an Associate Editor for Linux Journal.

Nice tutorial

Alexandro Colorado's picture

Awesome tutorial if you want to help us with the documenttion and experimientation of PyUNO please go to the Python wiki at the Wiki site.

Geek Guide
The DevOps Toolbox

Tools and Technologies for Scale and Reliability
by Linux Journal Editor Bill Childers

Get your free copy today

Sponsored by IBM

Upcoming Webinar
8 Signs You're Beyond Cron

Scheduling Crontabs With an Enterprise Scheduler
11am CDT, April 29th
Moderated by Linux Journal Contributor Mike Diehl

Sign up now

Sponsored by Skybot