The previous post showed a contrived example of how one could access the openbabel functionality in python using the boost libraries. There is alternative to boost to wrap around c/c++ code, it's called cython. Here is an example openbabel wrapper, exposing some very simple functionality. Just before diving in, you should know that there already exists a wrapper around openbabel in python (it is called pybel). What I'm showing here doesn't even come close to pybel in terms of usefulness, the idea here is to show a demo of how easy wrapping things in python is.

#! /usr/bin/python

from ez_setup import use_setuptools

from setuptools import setup, Extension, find_packages
from Cython.Distutils import build_ext

import sys, os
import glob

import subprocess as sub

def get_include(name="openbabel"):
p = sub.Popen('locate %s' % name ,stdout=sub.PIPE,stderr=sub.PIPE, shell=True)
output, errors = p.communicate()
include = [str.split("%s%s%s" %(os.sep, name, os.sep))[0] for str in output.split("\n") if str.endswith(".h")]

include = set(include)
assert len(include) == 1

return list(include)[0]

def main():

extensions = [

setup(name = 'pyopenbabel',
ext_package = 'pyopenbabel',
cmdclass = {'build_ext': build_ext},
ext_modules = extensions,
packages = find_packages()

if __name__ == '__main__':
The actual wrapper is in src/openbabel.pxd. In it you register which things from the openbabel headers you're going to use/wrap. Note that all the "cdef extern from openbabel/..." statements will fail if the inculudes defined in are not actually pointing to a place where a openbabel headers live. If you want to find out what a header file is, or how to find it - for openbabel or any other piece of code - google will provide a fast soultion.

# distutils: language = c++

from libcpp.string cimport string

from libcpp cimport bool

cdef extern from "openbabel/base.h" namespace "OpenBabel":
cdef cppclass OBBase:

cdef extern from "openbabel/mol.h" namespace "OpenBabel" :
cdef cppclass OBMol(OBBase):
OBMol() except +
const char *GetTitle(bool replaceNewlines = true)
unsigned int NumAtoms()
OBAtom *GetAtom(int idx)

cdef extern from "openbabel/atom.h" namespace "OpenBabel":
cdef cppclass OBAtom(OBBase):
double GetX()
double GetY()
double GetZ()

cdef extern from "openbabel/obconversion.h" namespace "OpenBabel" :
cdef cppclass OBConversion:
OBConversion() except +
bool SetInAndOutFormats(const char* inID, const char* outID)
bool SetInFormat(const char* inID)
bool ReadString(OBBase* pOb, string input)
bool ReadFile(OBBase* pOb, string filePath)

We register it's use in src/pyopenbabel.pyx Finally, in pyopenbabel/ put

from _pyopenbabel import *
This will magically import everything from the wrapper (registered as cython extension in Why do I think this is important? Because it's fast, easy and may allow interesting chemistry to happen.