3.0 Tools
Two of the tools developed for our work may be of interest to others. The newest one, Pyfort, is a tool for connecting Fortran to Python. CXX, described in a paper at the Seventh International Python Conference, is a tool for creating Python extensions using the C++ language rather than C. These tools and their documentation are available at the LLNL Python website, http://xfiles.llnl.gov. A link to this page is "Python at LLNL" on www.python.org.
3.1 Pyfort
Pyfort is a tool for connecting Fortran routines to Python. While connecting Python to Fortran routines is possible using such tools as SWIG ([3]), doing so requires considerable knowledge and a syntax unfamiliar to a Fortran-programming scientist. Since Fortran's 1990 standard included a syntax for describing the interfaces to Fortran routines, it seemed natural to build on that syntax as an input language to a Python / Fortran connection tool.
For example, here is the Pyfort input used to create a Python extension module "amodule" that connects Python to a routine f (n, x, y), where x is an array of length n that calculates results and stores them in an array y, also of length n.
module amodule
subroutine f (n, x, y)
integer n = size (x)
real x(n)
real, intent (out):: y (n)
end
end
The language used to describe the routine f is nearly identical to the Fortran interface block that would be written to ensure type checking in Fortran 95. Here the declaration of the integer n lets the user indicate that n is to be calculated from the size of the array x, so that it doesn't have to be passed as a separate argument from Python. Use of this feature is optional, of course.
After running Pyfort and creating the extension module, a process that takes just a few minutes, a dynamically-loaded module is available for importing into Python. The user can then call the Fortran subroutine f from Python using a natural syntax:
y = f (x)
Pyfort is capable of generating a sample input file for the Distutils. The user simply has to fill in the appropriate details to build and install the package. We hope to capture the community's knowledge about different Fortran compilers and systems to complete this facility.
3.2 Recent developments in CXX
CXX is a package of header files and supporting run-time source that enables the construction of extensions to Python in C++. The idea behind CXX, as described in the paper presented last year [4], is twofold. First, the Python C API is wrapped into a series of classes such as Object, Dict, and Tuple. C++ exceptions are converted into Python exceptions and all intermediate objects are cleaned up automatically in such as case. As a result, reference counting errors are nearly eliminated, along with complicated cleanup logic and extensive testing of return values from the Python C API.
For example, the following CXX code creates a dictionary and adds two named (Python) integers to it:
Dict d;
d ["one"] = Int (1);
d ["two"] = Int (2);
The CXX class hierarchy for this portion is shown in Table 1.
TABLE 1. CXX Class Heirarchy
Object
Type
Module
Integer
Float
Long
Complex
Char (Strings of length 1)
SeqBase<T>
Sequence (= SeqBase<Object>)
String
Tuple
List
Array (NumPy array)
MapBase<T>
Mapping (= MapBase<Object>)
Dict
Exception
StandardError
IndexError
RuntimeError
... (more classes corresponding to the Python exception heirarchy).
In addition there are a number of functions defined at the global (namespace Py) level. These include the usual binary arithmetic operators and stream output operators.
The second part of CXX is more experimental; it is an attempt to make it easier to construct your own objects and extension modules, without having to construct odd-looking tables and use mysterious non-standard constructions such as the infamous "staticforward" declaration. Barry Scott has substantially revised this section of CXX with some assistance from Paul Dubois.
Scott's new extension facilities for creating Python modules are now quite satisfying. For example, here is the coding to create a Python extension module named "example" containing a method "sum" that adds its floating-point arguments:
class example_module : public ExtensionModule<example_module>
{
public:
example_module(): ExtensionModule<example_module> ("example" )
{
add_varargs_method ("sum", ex_sum,
"sum (arglist) = sum of arguments");
initialize ( "documentation for module" );
}
virtual ~example_module () {}
private:
Object ex_sum (const Tuple &a)
{
Float f (0.0);
for( int i = 0; i < a.length (); i++ )
{
f = f + Float (a[i]);
}
return f;
}
}
Note the support provided by the CXX machinery. For example, if one of the arguments to "sum" is not a Python floating-point number, an exception is thrown, any temporary objects such as f are cleaned up, and a Python exception results.
Now we add the initialization routine Python requires, which now must only construct a permanent instance of our module class:
void initexample()
{
static example_module *example =
new example_module;
}
This example has been simplified from the one in the CXX package for expository purposes. Potential users should consult the files in the Demo directory for further examples, including use of the new extension object facility.