<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!--
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 -->

<html>
<head>
	<title>UIMA Python Annotators and the Pythonnator</title>
</head>

<body>
<h1>UIMA Python Annotators and the Pythonnator</h1>

<h2>What is a Python Annotator?</h2>
<p>A Python Annotator is a UIMA annotator component written in Python that can be used within the
UIMA SDK framework.
</p>

<h2>What is the Pythonnator?</h2>
<p>The Pythonnator is the linkage between the UIMA framework and a Python Annotator.
The Pythonnator is actually a UIMA C++ annotator which can be referenced by primitive annotator or CAS consumer descriptors.
The descriptor must define one configuration parameter, a second is optional:
  <ul>
    <code>SourceFile</code> (mandatory) - a string holding the name of the Python module to run, and<br>
    <code>DebugLevel</code> (optional) - an integer value that specifies the debug level for tracing. Default value is 0. A value of 101 turns on Pythonnator tracing. Values 1-100 are reserved for annotator developer use.
  </ul>
When the Pythonnator is initialized, e.g. at CPE initialization, the C++ code creates a Python interpreter, imports the specified script and calls the script's initialization method. Similarly, when other Pythonnator methods such as process() are called by the UIMA framework, the associated methods in the Python script are called.
</p>
<p>The Pythonnator also provides a Python library implementing an interface between Python and the UIMA APIs of the UIMA C++ framework.
</p>

<h2>Supported Platforms</h2>
<p>The Pythonnator has been tested with Python versions 2.7 on Linux. The build is currently broken for Python version 3.
</p>

<h2>Prerequisites</h2>
<p>The Pythonnator uses SWIG (http://www.swig.org/) to implement the Python library interface to UIMA. Tested with SWIG version 2.0.10.</p>
<p>The UIMA C++ framework is required.
</p>
<p>In addition to the Python interpreter, a Python development package (python-devel on Linux) is required for building the Pythonnator. The above mentioned Windows version includes a development package.</p>

<h2>Pythonnator Distribution</h2>
<p>Pythonnator code is distributed in source form and must be built on the target platform. A Makefile is supplied for Linux and a vcproj for Windows builds.</p>
<p>Pythonnator source and sample code is located in the $UIMACPP_HOME/scriptators directory.</p>

<h2>Setting Environment Variables</h2>
<p>The Pythonnator requires the standard environment for UIMA C++ components. In addition, PYTHONPATH must be set to identify where Python modules will be found.
</p>


<h2>Building and Installing the Pythonnator</h2>
Recursively copy the scriptators directory from the uimacpp distribution to a writable directory tree. CD to the writable scriptators/python directory.

<h3>On Linux</h3>
  <ul>
    <li><code>Check that you have the required Python and Swig packages installed</code></li>
    <li><code>make</code></li>
  </ul>

<h3>On Windows</h3>
  <ul>
    <li><code>Modify winmake.cmd to set the paths for your Python and Swig installs</code></li>
    <li><code>winmake</code></li>
  </ul>  
<p>Build results are the C++ annotator, _pythonnator.so on Linux or _pythonnator.dll on Windows, and the Python library interface to UIMA APIs, pythonnator.py.
</p>
<p>If you have write access to UIMA C++ distribution tree, on Linux copy _pythonnator.so and pythonnator.py to $UIMACPP_HOME/lib and add this directory to PYTHONPATH. On Windows copy _pythonnator.dll and pythonnator.py to $UIMACPP_HOME/bin and add this directory to PYTHONPATH.
</p>
<p>If you don't have write access, make sure that pythonnator.so|.dll is in the LD_LIBRARY_PATH or PATH, as appropriate, and copy pythonnator.py to the directory with the user's python modules and be sure to set PYTHONPATH to include that directory.
</p>

<h2>Testing the Pythonnator</h2>
</>A simple Python regular expression annotator <code>sample.py</code> with descriptor <code>PythonSample.xml</code> is included in the distribution. Make sure that sample.py is in PYTHONPATH and use the descriptor as with any other UIMA annotator descriptor.</p>

<h2>Known Pythonnator Issues</h2>
<p>
  <ul>
    <li>Not all of the UIMA C++ APIs have been swig'ed. Missing functions can be added by extending the source file uima.i.
    <li>The Python interpreter itself is not thread-safe. The Pythonnator uses Python's "global interpreter lock" to allow multiple Pythonnators to run in a multithreaded UIMA application such as the UIMA CPM. As a result multiple Pythonnotators running concurrently in different threads are serialized, potentially limiting performance when running on multicore hardware.
  </ul>
</p>

</body>
</html>
