jon parise // wednesday, november 26, 2014

PiP - Python in PHP

Both Python and PHP are what has become known as interpretted scripting languages. Each has achieved substantial popularity due primarily to their ability to facilitate rapid prototyping. As both a Python and PHP enthusiast, I wanted to bring these two systems together to promote even greater and more interesting development opportunities.

To that end, I've written a Python extension for PHP. In short, this extensions allows the Python interpretter to be embedded inside of PHP (think of PHP as the parent language with Python as its child). This allows native Python objects to be instantiated and manipulated from within PHP. There is also initial support for accessing PHP functions and data from within the embedded Python environment.

What exists right now is primarily a "proof of concept" implementation. It will serve as a solid starting point development.

The Python extension is available from its PECL package page. The source code currently lives in the PECL CVS repository. Some packaged distributions are also available.

Slides from my presentations at the 2002 International PHP Conference are available. I discussed internals and applications.

Examples

Here's an example of what it can do at the moment:

1. Evaluating Python Code from PHP
<?php
$a = "test";
$b = true;
$c = 50;
$d = 60.4;

$code = <<<EOD
import php

a = php.var('a')
b = php.var('b')
c = php.var('c')
d = php.var('d')

print a, b, c, d
print a, d / c + b, a
EOD;

py_eval($code);
?>
Result
test 1 50 60.4
test 2.208 test

2. Python Object Instantiation
# module.py
class TestClass:
    def __init__(self, foo):
        self.foo = foo

    def returnInt(self):
        return 1113

    def test(self, a, b = 'str'):
        return "a = %d, b = %s" % (a, b)

    def returnMe(self):
        return self

    def returnTuple(self):
        return (1, "two", 3.0)

    def returnList(self):
        return [1, "two", 3.0]

    def returnDict(self):
        d = {}
        d['one'] = 1
        d['two'] = 2
        d['three'] = 3
        return d

    def p(self, var):
        print var
<?php
$p = new Python('module', 'TestClass', array(435));
print $p->returnInt() . "\n";
print $p->test(1, 'bar') . "\n";

print $p->foo . "\n";
$p->foo = 987;
print $p->foo . "\n";

# $copy points to the same object
$copy = $p->returnMe();
print $copy->foo . "\n";
$p->foo = 987;
print $copy->foo . "\n";
?>
Result
1113
a = 1, b = bar
435
987
987
987

3. Type Conversion
<?php
var_dump($p->returnTuple());
var_dump($p->returnList());
var_dump($p->returnDict());

$a = array('one' => 1, 2, 3);
$p->p($a);

class Test {
    var $member = 'test';
}

$t = new Test();
$p->p($t);
?>
Result
array(3) {
  [0]=>
  int(1)
  [1]=>
  string(3) "two"
  [2]=>
  float(3)
}
array(3) {
  [0]=>
  int(1)
  [1]=>
  string(3) "two"
  [2]=>
  float(3)
}
array(3) {
  ["three"]=>
  int(3)
  ["two"]=>
  int(2)
  ["one"]=>
  int(1)
}
{'1': 3, '0': 2, 'one': 1}
{'member': 'test'}

As you can see, these current examples are fairly crude. In time, I'll work up some more detailed examples, but hopefully the above illustrate the extensions current cabilities.

A great deal of inspiration (in the forms design and code) for my Python in PHP extension came from the existing Java PHP extension and the mod_python Apache module.

Distributions

The current code is still considered "alpha" quality. It may contain bugs and definitely lacks features. There are still a large number of performance issues that require consideration.

The distribution is packaged using the PEAR installation tool. Under supported platforms, the extension can be build using the following command:

Building with PEAR
$ pear build
running: phpize
PHP Api Version        : 20020307
Zend Module Api No     : 20020429
Zend Extension Api No  : 20021010
Python installation directory? [autodetect] : 
building in /var/tmp/pear-build-jon/python-0.1
running: /home/jon/src/pear/PECL/python/configure --with-python
running: make
python.so copied to /home/jon/src/pear/PECL/python/python.so

A Microsoft Visual C++ 6.0 project file is also included to facilitate building under Windows.

Note that you'll need Python installed in order to build the extension. I'm currently building against Python 2.2.2. I've heard that ActivePython works, as well.

Also, a lot of the behavior (particularly with regard to type conversions) has not be finalized. The array to sequence conversion will definitely evolve, for instance.

Feel free to contact me with comments or suggestions (remember: the best suggestions come in diff -u format). I can't guarantee I'll have time to act on that immediately, but I will surely get to them soon.

These files are also available via anonymous FTP.