To install Python (including the links to Tkinter, which itself relies upon Tcl/Tk), download the latest version from http://www.python.org/2.0/#download.In our case, the latest version was Python 2.0. (Note the helpful messages built into the file name: BeOpen-Python-2.0.tar.gz.)

Unpack this file to its Python-2.0 home directory.

To get the Tkinter GUI side of things going, make sure that you’ve previously set up Tcl/Tk (as described earlier in this chapter) and you know which versions you’ve installed. We’ll assume Tk version 8.4 for the rest of our installation steps, which we’ve performed under Linux.

To get Tkinter to work, before you do anything else, make sure the Python compiler will later be able to pick up the libtk8.4.so library file (here we assume it’s lurking in the /usr/local/lib directory from the Tcl/Tk build earlier). You do this by ensuring that the LD_LIBRARY_PATH environment variable is correctly set:

$ LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH
$ export LD_LIBRARY_PATH

Before actually configuring Python, you’ll also need to go to the Python-2.0/Modules directory and edit the Setup file that you’ll find there. In this file you’ll find various instructions for compiling in the crucial _tkinter extensions. You’ll find that these have been commented out by default (in case you haven’t already set up Tcl/Tk and don’t want Tkinter).

Since in this case we need the Tkinter extension to get our DCOracle GUI example to work later on, we must alter our Setup file to include everything necessary for _tkinter (on Linux):

# The _tkinter module.
# The TKPATH variable is always enabled, to save you the effort.

TKPATH=:lib-tk
 _tkinter _tkinter.c tkappinit.c -DWITH_APPINIT 
    -I/usr/local/include 
    -I/usr/X11R6/include 
    -L/usr/local/lib 
    -ltk8.4 -ltcl8.4 
    -L/usr/X11R6/lib 
    -lX11

You’ll find many useful comments surrounding each line—for example, telling you what the X Windows library alternatives are. The really crucial line is the one detailing which versions of Tk and Tcl you’ll be pointing Python’s Tkinter at (in our case, 8.4 for both). Python 2.0 is preconfigured to work with Tcl/Tk versions 8 and over, so this is OK.

Now we can configure Python, make it, test it, and install it with all of its requisite libraries (for now, we’ll accept the default final destination for the Python interpreter, which is /usr/local/bin/python. See the README file for configuring in alternatives to this). Here is an outline of the steps:

$ cd Python-2.0
$ ./configure
$ make
$ make test
$ make install

The previous steps will also generate literally hundreds of compilation messages and test lines, which are excellent for debugging purposes should anything misbehave. If any of these steps goes wrong, be sure to sort it out before moving on. The ones to look out for are those involving the correct setting of LD_LIBRARY_PATH to get the right Tcl/Tk libraries, and those ensuring that the .. /Python-2.0/Modules/Setup file is set correctly for _tkinter usage on your particular flavor of operating system.

Assuming complete success, we should now be ready to get going with Tkinter. After running through the steps above, you may also want to confirm that your Python is slithering correctly with Tkinter before moving on. To do this, run one of the many thoughtfully provided demo programs. Make sure that you pick up your newly created Python by making /usr/local/bin dominant within your PATH variable, and if you get display problems, set DISPLAY to your local terminal:

$ cd ../Python-2.0/Demo/tkinter/matt
$ PATH=/usr/local/bin:$PATH
$ export PATH
$ DISPLAY=:0.0
$ export DISPLAY
$ python slider-demo-1.py

Download the source code for DCOracle from http://www.zope.org/Products/DCOracle/.

Unpack the latest stable download. If you need more information, see the extensive instructions accompanying the download (in our case, the latest download was 1.3.2).

Next, you’ll need to compile the DCOracle extensions. (Unfortunately, we have not yet found any binaries for the DCOracle database package, though we’re confident these will appear for Windows at some point. See the latest README files for up-to-date information.) First, though, move to where you’ll later compile the DCOracle extensions:

$ cd DCOracle-1.3.2/src

Here you’ll find various setup files, such as these:

Pick whichever of these is most appropriate for your machine’s version of Oracle (in our case, for Oracle 8.1.5, Setup-8.1.5 ) and copy it to a new Setup file, which the configuration process is expecting to find when you run it later:

$ cp Setup-8.1.5 Setup

Now you need to prepare a Makefile. With the download, you’ll receive a number of preinstallation Makefiles. Choose whichever one of these you want, based upon your version of Python. Because we were using Python 2.0, we chose the latest pre-installation Makefile, which in our case turned out to be Makefile.pre.in-1.5. Perform these two steps to create the necessary Makefile:

$ cp Makefile.pre.in-1.5
Makefile.pre.in
$ make -f Makefile.pre.in boot PYTHON=python

Notice PYTHON=python in the second line. This is simply an instruction to let the later compilation process know that our Python executable (available under /usr/local/bin) is actually called “python”, as opposed to something like “python20”.

We’re virtually there now, but as with other Oracle-accessing programs (like DBD::Oracle for Perl), DCOracle relies entirely on presupplied Oracle OCI code. You therefore need to make sure it knows where the Oracle OCI libraries are living:

$ ORACLE_HOME=/u01/app/oracle/product/8.1.5
$ export ORACLE_HOME
$ LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib:$ORACLE_HOME/lib
$ export LD_LIBRARY_PATH

Now you can safely compile DCOracle with one simple build step:

$ make

Once you’re through the compilation, start up the target Oracle database and its listener, and you should receive the same output you received from the presupplied Python test program:

$ python DCOracle_test.py scott/tiger@orcl
Import succeeded
Connect succeeded

This means you can continue.

To complete the installation process, make sure that your DCOracle extension is visible from the main /usr/local/bin/python program (this is not done with a make install command). To achieve this, go to the main DCOracle-1.3.2 directory and copy the two recently compiled extension files from the source compilation directory to the main DCOracle package directory:

$ cd DCOracle-1.3.2
$ cp src/Buffer.so DCOracle
$ cp src/oci_.so DCOracle

Now alter the previously unmentioned PYTHONPATH environment variable to ensure that Python can now find this new package directory under its DCOracle-1.3.2 parental home:

$ PYTHONPATH=/myUnpackDir/DCOracle-1.3.2:$PYTHONPATH
$ export PYTHONPATH