Add a strawman Python implementation extension.

git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@965360 13f79535-47bb-0310-9956-ffa450edef68

31 files changed, 2803 insertions, 0 deletions

diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/LICENSE b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/LICENSE
new file mode 100644
index 0000000000..2c5d23a2b4
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/LICENSE
@@ -0,0 +1,246 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed 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.
+
+===============================================================================================================
+
+Apache Tuscany SCA for Java Subcomponents
+=========================================: 
+
+The Tuscany SCA for Java release includes a number of subcomponents with
+separate copyright notices and license terms. Your use of the source
+code for the these subcomponents is subject to the terms and
+conditions of the following licenses.
+
+=================================================================================================================
+
+This module includes one file under the following BSD license:
+
+Copyright (c) Django Software Foundation and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+   
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of Django nor the names of its contributors may be used
+       to endorse or promote products derived from this software without
+       specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
+
+=================================================================================================================
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/META-INF/MANIFEST.MF b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/META-INF/MANIFEST.MF
new file mode 100644
index 0000000000..8155c1deb2
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/META-INF/MANIFEST.MF
@@ -0,0 +1,11 @@
+Manifest-Version: 1.0

+SCA-Version: 1.1

+Bundle-Name: Apache Tuscany Python Implementation Runtime

+Bundle-Vendor: The Apache Software Foundation

+Bundle-Version: 2.0.0

+Bundle-ManifestVersion: 2

+Bundle-License: http://www.apache.org/licenses/LICENSE-2.0.txt

+Bundle-Description: Apache Tuscany SCA Python Implementation Runtime

+Bundle-SymbolicName: org.apache.tuscany.sca.implementation.python.runtime

+Bundle-DocURL: http://www.apache.org/

+Bundle-RequiredExecutionEnvironment: J2SE-1.5,JavaSE-1.6
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/NOTICE b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/NOTICE
new file mode 100644
index 0000000000..aaa8297e5e
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/NOTICE
@@ -0,0 +1,13 @@
+${pom.name}
+Copyright (c) 2005 - 2010 The Apache Software Foundation
+
+This product includes software developed by
+The Apache Software Foundation (http://www.apache.org/).
+
+This product also includes software under the BSD license 
+(see the LICENSE file contained in this distribution), with
+the following copyright:
+
+Copyright (c) Django Software Foundation and individual contributors.
+All rights reserved.
+
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/jython-install b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/jython-install
new file mode 100755
index 0000000000..dc89bb3ec1
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/jython-install
@@ -0,0 +1,27 @@
+#!/bin/sh
+
+#  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.
+
+# Install Jython 2.5.2b1 jar in the local Maven repository, as it's not
+# yet available in a central Maven repository
+mkdir -p target
+cd target
+wget http://sourceforge.net/projects/jython/files/jython-dev/2.5.2b1/jython_installer-2.5.2b1.jar/download
+java -jar jython_installer-2.5.2b1.jar -s -d jython -t standalone
+mvn install:install-file -DgroupId=org.python -DartifactId=jython -Dversion=2.5.2 -Dpackaging=jar -Dfile=jython/jython.jar
+
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/pom.xml b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/pom.xml
new file mode 100644
index 0000000000..38d6915713
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/pom.xml
@@ -0,0 +1,100 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * 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.
+-->
+<project>
+
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.apache.tuscany.sca</groupId>
+        <artifactId>tuscany-modules</artifactId>
+        <version>2.0-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <artifactId>tuscany-implementation-python-runtime</artifactId>
+    <name>Apache Tuscany SCA Python Implementation Extension</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-sca-api</artifactId>
+            <version>2.0-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-implementation-python</artifactId>
+            <version>2.0-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-core</artifactId>
+            <version>2.0-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-databinding</artifactId>
+            <version>2.0-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.python</groupId>
+            <artifactId>jython</artifactId>
+            <version>2.5.2</version>
+        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>                                      
+            <artifactId>junit</artifactId>
+            <version>4.5</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-node-impl</artifactId>
+            <version>2.0-SNAPSHOT</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-implementation-java-runtime</artifactId>
+            <version>2.0-SNAPSHOT</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-binding-jsonrpc-runtime</artifactId>
+            <version>2.0-SNAPSHOT</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.tuscany.sca</groupId>
+            <artifactId>tuscany-host-jetty</artifactId>
+            <version>2.0-SNAPSHOT</version>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies> 
+</project>
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/java/org/apache/tuscany/sca/implementation/python/provider/PythonImplementationProvider.java b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/java/org/apache/tuscany/sca/implementation/python/provider/PythonImplementationProvider.java
new file mode 100644
index 0000000000..126dc2807b
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/java/org/apache/tuscany/sca/implementation/python/provider/PythonImplementationProvider.java
@@ -0,0 +1,94 @@
+/*
+ * 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.    
+ */
+
+package org.apache.tuscany.sca.implementation.python.provider;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.tuscany.sca.assembly.ComponentReference;
+import org.apache.tuscany.sca.core.invocation.ProxyFactory;
+import org.apache.tuscany.sca.implementation.python.PythonEval;
+import org.apache.tuscany.sca.implementation.python.PythonImplementation;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.provider.ImplementationProvider;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+import org.apache.tuscany.sca.runtime.RuntimeComponentService;
+import org.apache.tuscany.sca.runtime.RuntimeEndpointReference;
+import org.python.core.Py;
+import org.python.core.PyObject;
+import org.python.core.PyString;
+import org.python.core.PySystemState;
+import org.python.core.PyTuple;
+import org.python.util.PythonInterpreter;
+
+/**
+ * Implementation provider for Python component implementations.
+ *
+ * @version $Rev$ $Date$
+ */
+class PythonImplementationProvider implements ImplementationProvider {
+    final RuntimeComponent component;
+    final PythonImplementation implementation;
+    PythonInterpreter python;
+    PyObject callable;
+    ProxyFactory pxFactory;
+    
+    PythonImplementationProvider(final RuntimeComponent comp, final PythonImplementation impl, ProxyFactory pxf) {
+        component = comp;
+        implementation = impl;
+        pxFactory = pxf;
+    }
+
+    public void start() {
+    	final PySystemState pss = new PySystemState();
+    	pss.path.insert(0, new PyString(implementation.getLocation()));
+    	pss.path.insert(0, new PyString(getClass().getProtectionDomain().getCodeSource().getLocation().getFile()));
+    	python = new PythonInterpreter(null, pss);
+    	python.exec("from invoker import *");
+    	
+    	final List<PyObject> px = new ArrayList<PyObject>();
+    	for (ComponentReference r: component.getReferences()) {
+    		final PythonEval pe = pxFactory.createProxy(PythonEval.class, (RuntimeEndpointReference)r.getEndpointReferences().get(0));
+            px.add(Py.java2py(new PythonEval() {
+            	@Override
+            	public String eval(final String args) throws Exception {
+            		final String v = pe.eval(args); 
+            		return v;
+            	}
+            }));
+    	}
+
+    	PyObject mkc = python.get("mkcomponent");
+    	callable = mkc.__call__(new PyString(component.getName()), new PyString(implementation.getScript()), new PyTuple(px.toArray(new PyObject[0])));
+    }
+
+    public void stop() {
+    	python.cleanup();
+    }
+
+    public boolean supportsOneWayInvocation() {
+        return false;
+    }
+
+    public Invoker createInvoker(final RuntimeComponentService s, final Operation op) {
+        return new PythonInvoker(python, callable, op);
+    }
+}
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/java/org/apache/tuscany/sca/implementation/python/provider/PythonImplementationProviderFactory.java b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/java/org/apache/tuscany/sca/implementation/python/provider/PythonImplementationProviderFactory.java
new file mode 100644
index 0000000000..1a09e1cc99
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/java/org/apache/tuscany/sca/implementation/python/provider/PythonImplementationProviderFactory.java
@@ -0,0 +1,49 @@
+/*
+ * 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.    
+ */
+
+package org.apache.tuscany.sca.implementation.python.provider;
+
+import org.apache.tuscany.sca.core.ExtensionPointRegistry;
+import org.apache.tuscany.sca.core.invocation.ExtensibleProxyFactory;
+import org.apache.tuscany.sca.core.invocation.ProxyFactory;
+import org.apache.tuscany.sca.implementation.python.PythonImplementation;
+import org.apache.tuscany.sca.provider.ImplementationProvider;
+import org.apache.tuscany.sca.provider.ImplementationProviderFactory;
+import org.apache.tuscany.sca.runtime.RuntimeComponent;
+
+/**
+ * A factory for Python implementation providers.
+ *
+ * @version $Rev$ $Date$
+ */
+public class PythonImplementationProviderFactory implements ImplementationProviderFactory<PythonImplementation> {
+	final ProxyFactory pxFactory;
+    
+    public PythonImplementationProviderFactory(final ExtensionPointRegistry ep) {
+    	pxFactory = ExtensibleProxyFactory.getInstance(ep);
+    }
+
+    public ImplementationProvider createImplementationProvider(final RuntimeComponent comp, final PythonImplementation impl) {
+        return new PythonImplementationProvider(comp, impl, pxFactory);
+    }
+    
+    public Class<PythonImplementation> getModelType() {
+        return PythonImplementation.class;
+    }
+}
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/java/org/apache/tuscany/sca/implementation/python/provider/PythonInvoker.java b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/java/org/apache/tuscany/sca/implementation/python/provider/PythonInvoker.java
new file mode 100644
index 0000000000..da342bd03c
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/java/org/apache/tuscany/sca/implementation/python/provider/PythonInvoker.java
@@ -0,0 +1,59 @@
+/*
+ * 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.    
+ */
+
+package org.apache.tuscany.sca.implementation.python.provider;
+
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.invocation.Invoker;
+import org.apache.tuscany.sca.invocation.Message;
+import org.python.core.PyObject;
+import org.python.core.PyString;
+import org.python.util.PythonInterpreter;
+
+/**
+ * An invoker for Python components.
+ *
+ * @version $Rev$ $Date$
+ */
+class PythonInvoker implements Invoker {
+    final PythonInterpreter python;
+    final PyObject callable;
+    final Operation operation;
+
+    PythonInvoker(final PythonInterpreter py, final PyObject c, final Operation op) {
+        python = py;
+        callable = c;
+        operation = op;
+    }
+
+    String apply(final String req) {
+    	PyObject r = callable.__call__(new PyString(req));
+    	return r.toString();
+    }
+
+    public Message invoke(final Message msg) {
+        try {
+            msg.setBody(apply((String)((Object[])msg.getBody())[0]));
+        } catch (Exception e) {
+        	e.printStackTrace();
+            msg.setFaultBody(e.getCause());
+        }
+        return msg;
+    }
+}
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/META-INF/services/org.apache.tuscany.sca.provider.ImplementationProviderFactory b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/META-INF/services/org.apache.tuscany.sca.provider.ImplementationProviderFactory
new file mode 100644
index 0000000000..3c1e6c4406
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/META-INF/services/org.apache.tuscany.sca.provider.ImplementationProviderFactory
@@ -0,0 +1,20 @@
+# 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. 

+

+# Implementation provider for Python components

+org.apache.tuscany.sca.implementation.python.provider.PythonImplementationProviderFactory;model=org.apache.tuscany.sca.implementation.python.PythonImplementation

+

diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/atomutil.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/atomutil.py
new file mode 100644
index 0000000000..6c0a7c9a81
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/atomutil.py
@@ -0,0 +1,120 @@
+#  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.
+
+# ATOM data conversion functions
+
+from util import *
+from elemutil import *
+from xmlutil import *
+
+# Convert a list of elements to a list of values representing an ATOM entry
+def entryElementsToValues(e):
+    lt = filter(selector((element, "'title")), e)
+    t = "" if isNil(lt) else elementValue(car(lt))
+    li = filter(selector((element, "'id")), e)
+    i = "" if isNil(li) else elementValue(car(li))
+    lc = filter(selector((element, "'content")), e)
+    return (t, i, elementValue(car(lc)))
+
+# Convert a list of elements to a list of values representing ATOM entries
+def entriesElementsToValues(e):
+    if isNil(e):
+        return e
+    return cons(entryElementsToValues(car(e)), entriesElementsToValues(cdr(e)))
+
+# Convert a list of strings to a list of values representing an ATOM entry
+def readATOMEntry(l):
+    e = readXML(l)
+    if isNil(e):
+        return ()
+    return entryElementsToValues(car(e))
+
+# Convert a list of values representy an ATOM entry to a value
+def entryValue(e):
+    v = elementsToValues((caddr(e),))
+    return cons(car(e), (cadr(e), cdr(car(v))))
+
+# Return true if a list of strings represents an ATOM feed
+def isATOMFeed(l):
+    if isNil(l):
+        return False
+    if car(l)[0:5] != "<?xml":
+        return False
+    return contains(car(l), "<feed")
+
+# Convert a list of strings to a list of values representing an ATOM feed
+def readATOMFeed(l):
+    f = readXML(l)
+    if isNil(f):
+        return ()
+    t = filter(selector((element, "'title")), car(f))
+    i = filter(selector((element, "'id")), car(f))
+    e = filter(selector((element, "'entry")), car(f))
+    if isNil(e):
+        return (elementValue(car(t)), elementValue(car(i)))
+    return cons(elementValue(car(t)), cons(elementValue(car(i)), entriesElementsToValues(e)))
+
+# Convert an ATOM feed containing elements to an ATOM feed containing values
+def feedValuesLoop(e):
+    if (isNil(e)):
+        return e
+    return cons(entryValue(car(e)), feedValuesLoop(cdr(e)))
+
+def feedValues(e):
+    return cons(car(e), cons(cadr(e), feedValuesLoop(cddr(e))))
+
+# Convert a list of values representy an ATOM entry to a list of elements
+def entryElement(l):
+    return (element, "'entry", (attribute, "'xmlns", "http://www.w3.org/2005/Atom"),
+            (element, "'title", (attribute, "'type", "text"), car(l)),
+            (element, "'id", cadr(l)),
+            (element, "'content", (attribute, "'type", ("application/xml" if isList(caddr(l)) else "text")), caddr(l)),
+            (element, "'link", (attribute, "'href", cadr(l))))
+
+# Convert a list of values representing ATOM entries to a list of elements
+def entriesElements(l):
+    if isNil(l):
+        return l
+    return cons(entryElement(car(l)), entriesElements(cdr(l)))
+
+# Convert a list of values representing an ATOM entry to an ATOM entry
+def writeATOMEntry(l):
+    return writeXML((entryElement(l),), True)
+
+# Convert a list of values representing an ATOM feed to an ATOM feed
+def writeATOMFeed(l):
+    f = (element, "'feed", (attribute, "'xmlns", "http://www.w3.org/2005/Atom"),
+            (element, "'title", (attribute, "'type", "text"), car(l)),
+            (element, "'id", cadr(l)))
+    if isNil(cddr(l)):
+        return writeXML((f,), True)
+    fe = append(f, entriesElements(cddr(l)))
+    return writeXML((fe,), True)
+
+# Convert an ATOM entry containing a value to an ATOM entry containing an item element
+def entryValuesToElements(v):
+    return cons(car(v), cons(cadr(v), valuesToElements((cons("'item", caddr(v)),))))
+
+# Convert an ATOM feed containing values to an ATOM feed containing elements
+def feedValuesToElementsLoop(v):
+    if isNil(v):
+        return v
+    return cons(entryValuesToElements(car(v)), feedValuesToElementsLoop(cdr(v)))
+
+def feedValuesToElements(v):
+    return cons(car(v), cons(cadr(v), feedValuesToElementsLoop(cddr(v))))
+
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/__init__.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/__init__.py
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/__init__.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/__init__.py
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/__init__.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/__init__.py
new file mode 100644
index 0000000000..15b7173976
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/__init__.py
@@ -0,0 +1,252 @@
+r"""
+A simple, fast, extensible JSON encoder and decoder
+
+JSON (JavaScript Object Notation) <http://json.org> is a subset of
+JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
+interchange format.
+
+simplejson exposes an API familiar to uses of the standard library
+marshal and pickle modules.
+
+Encoding basic Python object hierarchies::
+    
+    >>> import simplejson
+    >>> simplejson.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
+    '["foo", {"bar": ["baz", null, 1.0, 2]}]'
+    >>> print simplejson.dumps("\"foo\bar")
+    "\"foo\bar"
+    >>> print simplejson.dumps(u'\u1234')
+    "\u1234"
+    >>> print simplejson.dumps('\\')
+    "\\"
+    >>> print simplejson.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
+    {"a": 0, "b": 0, "c": 0}
+    >>> from StringIO import StringIO
+    >>> io = StringIO()
+    >>> simplejson.dump(['streaming API'], io)
+    >>> io.getvalue()
+    '["streaming API"]'
+
+Compact encoding::
+
+    >>> import simplejson
+    >>> simplejson.dumps([1,2,3,{'4': 5, '6': 7}], separators=(',',':'))
+    '[1,2,3,{"4":5,"6":7}]'
+
+Pretty printing::
+
+    >>> import simplejson
+    >>> print simplejson.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4)
+    {
+        "4": 5, 
+        "6": 7
+    }
+
+Decoding JSON::
+    
+    >>> import simplejson
+    >>> simplejson.loads('["foo", {"bar":["baz", null, 1.0, 2]}]')
+    [u'foo', {u'bar': [u'baz', None, 1.0, 2]}]
+    >>> simplejson.loads('"\\"foo\\bar"')
+    u'"foo\x08ar'
+    >>> from StringIO import StringIO
+    >>> io = StringIO('["streaming API"]')
+    >>> simplejson.load(io)
+    [u'streaming API']
+
+Specializing JSON object decoding::
+
+    >>> import simplejson
+    >>> def as_complex(dct):
+    ...     if '__complex__' in dct:
+    ...         return complex(dct['real'], dct['imag'])
+    ...     return dct
+    ... 
+    >>> simplejson.loads('{"__complex__": true, "real": 1, "imag": 2}',
+    ...     object_hook=as_complex)
+    (1+2j)
+
+Extending JSONEncoder::
+    
+    >>> import simplejson
+    >>> class ComplexEncoder(simplejson.JSONEncoder):
+    ...     def default(self, obj):
+    ...         if isinstance(obj, complex):
+    ...             return [obj.real, obj.imag]
+    ...         return simplejson.JSONEncoder.default(self, obj)
+    ... 
+    >>> dumps(2 + 1j, cls=ComplexEncoder)
+    '[2.0, 1.0]'
+    >>> ComplexEncoder().encode(2 + 1j)
+    '[2.0, 1.0]'
+    >>> list(ComplexEncoder().iterencode(2 + 1j))
+    ['[', '2.0', ', ', '1.0', ']']
+    
+
+Note that the JSON produced by this module's default settings
+is a subset of YAML, so it may be used as a serializer for that as well.
+"""
+__version__ = '1.5'
+__all__ = [
+    'dump', 'dumps', 'load', 'loads',
+    'JSONDecoder', 'JSONEncoder',
+]
+
+from django.utils.simplejson.decoder import JSONDecoder
+from django.utils.simplejson.encoder import JSONEncoder
+
+def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
+        allow_nan=True, cls=None, indent=None, **kw):
+    """
+    Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
+    ``.write()``-supporting file-like object).
+
+    If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types
+    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) 
+    will be skipped instead of raising a ``TypeError``.
+
+    If ``ensure_ascii`` is ``False``, then the some chunks written to ``fp``
+    may be ``unicode`` instances, subject to normal Python ``str`` to
+    ``unicode`` coercion rules.  Unless ``fp.write()`` explicitly
+    understands ``unicode`` (as in ``codecs.getwriter()``) this is likely
+    to cause an error.
+
+    If ``check_circular`` is ``False``, then the circular reference check
+    for container types will be skipped and a circular reference will
+    result in an ``OverflowError`` (or worse).
+
+    If ``allow_nan`` is ``False``, then it will be a ``ValueError`` to
+    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
+    in strict compliance of the JSON specification, instead of using the
+    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
+
+    If ``indent`` is a non-negative integer, then JSON array elements and object
+    members will be pretty-printed with that indent level.  An indent level
+    of 0 will only insert newlines.  ``None`` is the most compact representation.
+
+    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
+    ``.default()`` method to serialize additional types), specify it with
+    the ``cls`` kwarg.
+    """
+    if cls is None:
+        cls = JSONEncoder
+    iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,
+        check_circular=check_circular, allow_nan=allow_nan, indent=indent,
+        **kw).iterencode(obj)
+    # could accelerate with writelines in some versions of Python, at
+    # a debuggability cost
+    for chunk in iterable:
+        fp.write(chunk)
+
+def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
+        allow_nan=True, cls=None, indent=None, separators=None, **kw):
+    """
+    Serialize ``obj`` to a JSON formatted ``str``.
+
+    If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types
+    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) 
+    will be skipped instead of raising a ``TypeError``.
+
+    If ``ensure_ascii`` is ``False``, then the return value will be a
+    ``unicode`` instance subject to normal Python ``str`` to ``unicode``
+    coercion rules instead of being escaped to an ASCII ``str``.
+
+    If ``check_circular`` is ``False``, then the circular reference check
+    for container types will be skipped and a circular reference will
+    result in an ``OverflowError`` (or worse).
+
+    If ``allow_nan`` is ``False``, then it will be a ``ValueError`` to
+    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
+    strict compliance of the JSON specification, instead of using the
+    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).
+
+    If ``indent`` is a non-negative integer, then JSON array elements and
+    object members will be pretty-printed with that indent level.  An indent
+    level of 0 will only insert newlines.  ``None`` is the most compact
+    representation.
+
+    If ``separators`` is an ``(item_separator, dict_separator)`` tuple
+    then it will be used instead of the default ``(', ', ': ')`` separators.
+    ``(',', ':')`` is the most compact JSON representation.
+
+    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
+    ``.default()`` method to serialize additional types), specify it with
+    the ``cls`` kwarg.
+    """
+    if cls is None:
+        cls = JSONEncoder
+    return cls(
+        skipkeys=skipkeys, ensure_ascii=ensure_ascii,
+        check_circular=check_circular, allow_nan=allow_nan, indent=indent,
+        separators=separators,
+        **kw).encode(obj)
+
+def load(fp, encoding=None, cls=None, object_hook=None, **kw):
+    """
+    Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
+    a JSON document) to a Python object.
+
+    If the contents of ``fp`` is encoded with an ASCII based encoding other
+    than utf-8 (e.g. latin-1), then an appropriate ``encoding`` name must
+    be specified.  Encodings that are not ASCII based (such as UCS-2) are
+    not allowed, and should be wrapped with
+    ``codecs.getreader(fp)(encoding)``, or simply decoded to a ``unicode``
+    object and passed to ``loads()``
+
+    ``object_hook`` is an optional function that will be called with the
+    result of any object literal decode (a ``dict``).  The return value of
+    ``object_hook`` will be used instead of the ``dict``.  This feature
+    can be used to implement custom decoders (e.g. JSON-RPC class hinting).
+    
+    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
+    kwarg.
+    """
+    if cls is None:
+        cls = JSONDecoder
+    if object_hook is not None:
+        kw['object_hook'] = object_hook
+    return cls(encoding=encoding, **kw).decode(fp.read())
+
+def loads(s, encoding=None, cls=None, object_hook=None, **kw):
+    """
+    Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON
+    document) to a Python object.
+
+    If ``s`` is a ``str`` instance and is encoded with an ASCII based encoding
+    other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name
+    must be specified.  Encodings that are not ASCII based (such as UCS-2)
+    are not allowed and should be decoded to ``unicode`` first.
+
+    ``object_hook`` is an optional function that will be called with the
+    result of any object literal decode (a ``dict``).  The return value of
+    ``object_hook`` will be used instead of the ``dict``.  This feature
+    can be used to implement custom decoders (e.g. JSON-RPC class hinting).
+
+    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
+    kwarg.
+    """
+    if cls is None:
+        cls = JSONDecoder
+    if object_hook is not None:
+        kw['object_hook'] = object_hook
+    return cls(encoding=encoding, **kw).decode(s)
+
+def read(s):
+    """
+    json-py API compatibility hook.  Use loads(s) instead.
+    """
+    import warnings
+    warnings.warn("simplejson.loads(s) should be used instead of read(s)",
+        DeprecationWarning)
+    return loads(s)
+
+def write(obj):
+    """
+    json-py API compatibility hook.  Use dumps(s) instead.
+    """
+    import warnings
+    warnings.warn("simplejson.dumps(s) should be used instead of write(s)",
+        DeprecationWarning)
+    return dumps(obj)
+
+
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/decoder.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/decoder.py
new file mode 100644
index 0000000000..66f68a200b
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/decoder.py
@@ -0,0 +1,273 @@
+"""
+Implementation of JSONDecoder
+"""
+import re
+
+from django.utils.simplejson.scanner import Scanner, pattern
+
+FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL
+
+def _floatconstants():
+    import struct
+    import sys
+    _BYTES = '7FF80000000000007FF0000000000000'.decode('hex')
+    if sys.byteorder != 'big':
+        _BYTES = _BYTES[:8][::-1] + _BYTES[8:][::-1]
+    nan, inf = struct.unpack('dd', _BYTES)
+    return nan, inf, -inf
+
+NaN, PosInf, NegInf = _floatconstants()
+
+def linecol(doc, pos):
+    lineno = doc.count('\n', 0, pos) + 1
+    if lineno == 1:
+        colno = pos
+    else:
+        colno = pos - doc.rindex('\n', 0, pos)
+    return lineno, colno
+
+def errmsg(msg, doc, pos, end=None):
+    lineno, colno = linecol(doc, pos)
+    if end is None:
+        return '%s: line %d column %d (char %d)' % (msg, lineno, colno, pos)
+    endlineno, endcolno = linecol(doc, end)
+    return '%s: line %d column %d - line %d column %d (char %d - %d)' % (
+        msg, lineno, colno, endlineno, endcolno, pos, end)
+
+_CONSTANTS = {
+    '-Infinity': NegInf,
+    'Infinity': PosInf,
+    'NaN': NaN,
+    'true': True,
+    'false': False,
+    'null': None,
+}
+
+def JSONConstant(match, context, c=_CONSTANTS):
+    return c[match.group(0)], None
+pattern('(-?Infinity|NaN|true|false|null)')(JSONConstant)
+
+def JSONNumber(match, context):
+    match = JSONNumber.regex.match(match.string, *match.span())
+    integer, frac, exp = match.groups()
+    if frac or exp:
+        res = float(integer + (frac or '') + (exp or ''))
+    else:
+        res = int(integer)
+    return res, None
+pattern(r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?')(JSONNumber)
+
+STRINGCHUNK = re.compile(r'(.*?)(["\\])', FLAGS)
+BACKSLASH = {
+    '"': u'"', '\\': u'\\', '/': u'/',
+    'b': u'\b', 'f': u'\f', 'n': u'\n', 'r': u'\r', 't': u'\t',
+}
+
+DEFAULT_ENCODING = "utf-8"
+
+def scanstring(s, end, encoding=None, _b=BACKSLASH, _m=STRINGCHUNK.match):
+    if encoding is None:
+        encoding = DEFAULT_ENCODING
+    chunks = []
+    _append = chunks.append
+    begin = end - 1
+    while 1:
+        chunk = _m(s, end)
+        if chunk is None:
+            raise ValueError(
+                errmsg("Unterminated string starting at", s, begin))
+        end = chunk.end()
+        content, terminator = chunk.groups()
+        if content:
+            if not isinstance(content, unicode):
+                content = unicode(content, encoding)
+            _append(content)
+        if terminator == '"':
+            break
+        try:
+            esc = s[end]
+        except IndexError:
+            raise ValueError(
+                errmsg("Unterminated string starting at", s, begin))
+        if esc != 'u':
+            try:
+                m = _b[esc]
+            except KeyError:
+                raise ValueError(
+                    errmsg("Invalid \\escape: %r" % (esc,), s, end))
+            end += 1
+        else:
+            esc = s[end + 1:end + 5]
+            try:
+                m = unichr(int(esc, 16))
+                if len(esc) != 4 or not esc.isalnum():
+                    raise ValueError
+            except ValueError:
+                raise ValueError(errmsg("Invalid \\uXXXX escape", s, end))
+            end += 5
+        _append(m)
+    return u''.join(chunks), end
+
+def JSONString(match, context):
+    encoding = getattr(context, 'encoding', None)
+    return scanstring(match.string, match.end(), encoding)
+pattern(r'"')(JSONString)
+
+WHITESPACE = re.compile(r'\s*', FLAGS)
+
+def JSONObject(match, context, _w=WHITESPACE.match):
+    pairs = {}
+    s = match.string
+    end = _w(s, match.end()).end()
+    nextchar = s[end:end + 1]
+    # trivial empty object
+    if nextchar == '}':
+        return pairs, end + 1
+    if nextchar != '"':
+        raise ValueError(errmsg("Expecting property name", s, end))
+    end += 1
+    encoding = getattr(context, 'encoding', None)
+    iterscan = JSONScanner.iterscan
+    while True:
+        key, end = scanstring(s, end, encoding)
+        end = _w(s, end).end()
+        if s[end:end + 1] != ':':
+            raise ValueError(errmsg("Expecting : delimiter", s, end))
+        end = _w(s, end + 1).end()
+        try:
+            value, end = iterscan(s, idx=end, context=context).next()
+        except StopIteration:
+            raise ValueError(errmsg("Expecting object", s, end))
+        pairs[key] = value
+        end = _w(s, end).end()
+        nextchar = s[end:end + 1]
+        end += 1
+        if nextchar == '}':
+            break
+        if nextchar != ',':
+            raise ValueError(errmsg("Expecting , delimiter", s, end - 1))
+        end = _w(s, end).end()
+        nextchar = s[end:end + 1]
+        end += 1
+        if nextchar != '"':
+            raise ValueError(errmsg("Expecting property name", s, end - 1))
+    object_hook = getattr(context, 'object_hook', None)
+    if object_hook is not None:
+        pairs = object_hook(pairs)
+    return pairs, end
+pattern(r'{')(JSONObject)
+            
+def JSONArray(match, context, _w=WHITESPACE.match):
+    values = []
+    s = match.string
+    end = _w(s, match.end()).end()
+    # look-ahead for trivial empty array
+    nextchar = s[end:end + 1]
+    if nextchar == ']':
+        return values, end + 1
+    iterscan = JSONScanner.iterscan
+    while True:
+        try:
+            value, end = iterscan(s, idx=end, context=context).next()
+        except StopIteration:
+            raise ValueError(errmsg("Expecting object", s, end))
+        values.append(value)
+        end = _w(s, end).end()
+        nextchar = s[end:end + 1]
+        end += 1
+        if nextchar == ']':
+            break
+        if nextchar != ',':
+            raise ValueError(errmsg("Expecting , delimiter", s, end))
+        end = _w(s, end).end()
+    return values, end
+pattern(r'\[')(JSONArray)
+ 
+ANYTHING = [
+    JSONObject,
+    JSONArray,
+    JSONString,
+    JSONConstant,
+    JSONNumber,
+]
+
+JSONScanner = Scanner(ANYTHING)
+
+class JSONDecoder(object):
+    """
+    Simple JSON <http://json.org> decoder
+
+    Performs the following translations in decoding:
+    
+    +---------------+-------------------+
+    | JSON          | Python            |
+    +===============+===================+
+    | object        | dict              |
+    +---------------+-------------------+
+    | array         | list              |
+    +---------------+-------------------+
+    | string        | unicode           |
+    +---------------+-------------------+
+    | number (int)  | int, long         |
+    +---------------+-------------------+
+    | number (real) | float             |
+    +---------------+-------------------+
+    | true          | True              |
+    +---------------+-------------------+
+    | false         | False             |
+    +---------------+-------------------+
+    | null          | None              |
+    +---------------+-------------------+
+
+    It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
+    their corresponding ``float`` values, which is outside the JSON spec.
+    """
+
+    _scanner = Scanner(ANYTHING)
+    __all__ = ['__init__', 'decode', 'raw_decode']
+
+    def __init__(self, encoding=None, object_hook=None):
+        """
+        ``encoding`` determines the encoding used to interpret any ``str``
+        objects decoded by this instance (utf-8 by default).  It has no
+        effect when decoding ``unicode`` objects.
+        
+        Note that currently only encodings that are a superset of ASCII work,
+        strings of other encodings should be passed in as ``unicode``.
+
+        ``object_hook``, if specified, will be called with the result
+        of every JSON object decoded and its return value will be used in
+        place of the given ``dict``.  This can be used to provide custom
+        deserializations (e.g. to support JSON-RPC class hinting).
+        """
+        self.encoding = encoding
+        self.object_hook = object_hook
+
+    def decode(self, s, _w=WHITESPACE.match):
+        """
+        Return the Python representation of ``s`` (a ``str`` or ``unicode``
+        instance containing a JSON document)
+        """
+        obj, end = self.raw_decode(s, idx=_w(s, 0).end())
+        end = _w(s, end).end()
+        if end != len(s):
+            raise ValueError(errmsg("Extra data", s, end, len(s)))
+        return obj
+
+    def raw_decode(self, s, **kw):
+        """
+        Decode a JSON document from ``s`` (a ``str`` or ``unicode`` beginning
+        with a JSON document) and return a 2-tuple of the Python
+        representation and the index in ``s`` where the document ended.
+
+        This can be used to decode a JSON document from a string that may
+        have extraneous data at the end.
+        """
+        kw.setdefault('context', self)
+        try:
+            obj, end = self._scanner.iterscan(s, **kw).next()
+        except StopIteration:
+            raise ValueError("No JSON object could be decoded")
+        return obj, end
+
+__all__ = ['JSONDecoder']
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/encoder.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/encoder.py
new file mode 100644
index 0000000000..c83c6873eb
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/encoder.py
@@ -0,0 +1,331 @@
+"""
+Implementation of JSONEncoder
+"""
+import re
+
+ESCAPE = re.compile(r'[\x00-\x19\\"\b\f\n\r\t]')
+ESCAPE_ASCII = re.compile(r'([\\"/]|[^\ -~])')
+ESCAPE_DCT = {
+    # escape all forward slashes to prevent </script> attack
+    '/': '\\/',
+    '\\': '\\\\',
+    '"': '\\"',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+}
+for i in range(0x20):
+    ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,))
+
+# assume this produces an infinity on all machines (probably not guaranteed)
+INFINITY = float('1e66666')
+
+def floatstr(o, allow_nan=True):
+    # Check for specials.  Note that this type of test is processor- and/or
+    # platform-specific, so do tests which don't depend on the internals.
+
+    if o != o:
+        text = 'NaN'
+    elif o == INFINITY:
+        text = 'Infinity'
+    elif o == -INFINITY:
+        text = '-Infinity'
+    else:
+        return str(o)
+
+    if not allow_nan:
+        raise ValueError("Out of range float values are not JSON compliant: %r"
+            % (o,))
+
+    return text
+
+
+def encode_basestring(s):
+    """
+    Return a JSON representation of a Python string
+    """
+    def replace(match):
+        return ESCAPE_DCT[match.group(0)]
+    return '"' + ESCAPE.sub(replace, s) + '"'
+
+def encode_basestring_ascii(s):
+    def replace(match):
+        s = match.group(0)
+        try:
+            return ESCAPE_DCT[s]
+        except KeyError:
+            return '\\u%04x' % (ord(s),)
+    return '"' + str(ESCAPE_ASCII.sub(replace, s)) + '"'
+        
+
+class JSONEncoder(object):
+    """
+    Extensible JSON <http://json.org> encoder for Python data structures.
+
+    Supports the following objects and types by default:
+    
+    +-------------------+---------------+
+    | Python            | JSON          |
+    +===================+===============+
+    | dict              | object        |
+    +-------------------+---------------+
+    | list, tuple       | array         |
+    +-------------------+---------------+
+    | str, unicode      | string        |
+    +-------------------+---------------+
+    | int, long, float  | number        |
+    +-------------------+---------------+
+    | True              | true          |
+    +-------------------+---------------+
+    | False             | false         |
+    +-------------------+---------------+
+    | None              | null          |
+    +-------------------+---------------+
+
+    To extend this to recognize other objects, subclass and implement a
+    ``.default()`` method with another method that returns a serializable
+    object for ``o`` if possible, otherwise it should call the superclass
+    implementation (to raise ``TypeError``).
+    """
+    __all__ = ['__init__', 'default', 'encode', 'iterencode']
+    item_separator = ', '
+    key_separator = ': '
+    def __init__(self, skipkeys=False, ensure_ascii=True,
+            check_circular=True, allow_nan=True, sort_keys=False,
+            indent=None, separators=None):
+        """
+        Constructor for JSONEncoder, with sensible defaults.
+
+        If skipkeys is False, then it is a TypeError to attempt
+        encoding of keys that are not str, int, long, float or None.  If
+        skipkeys is True, such items are simply skipped.
+
+        If ensure_ascii is True, the output is guaranteed to be str
+        objects with all incoming unicode characters escaped.  If
+        ensure_ascii is false, the output will be unicode object.
+
+        If check_circular is True, then lists, dicts, and custom encoded
+        objects will be checked for circular references during encoding to
+        prevent an infinite recursion (which would cause an OverflowError).
+        Otherwise, no such check takes place.
+
+        If allow_nan is True, then NaN, Infinity, and -Infinity will be
+        encoded as such.  This behavior is not JSON specification compliant,
+        but is consistent with most JavaScript based encoders and decoders.
+        Otherwise, it will be a ValueError to encode such floats.
+
+        If sort_keys is True, then the output of dictionaries will be
+        sorted by key; this is useful for regression tests to ensure
+        that JSON serializations can be compared on a day-to-day basis.
+
+        If indent is a non-negative integer, then JSON array
+        elements and object members will be pretty-printed with that
+        indent level.  An indent level of 0 will only insert newlines.
+        None is the most compact representation.
+
+        If specified, separators should be a (item_separator, key_separator)
+        tuple. The default is (', ', ': '). To get the most compact JSON
+        representation you should specify (',', ':') to eliminate whitespace.
+        """
+
+        self.skipkeys = skipkeys
+        self.ensure_ascii = ensure_ascii
+        self.check_circular = check_circular
+        self.allow_nan = allow_nan
+        self.sort_keys = sort_keys
+        self.indent = indent
+        self.current_indent_level = 0
+        if separators is not None:
+            self.item_separator, self.key_separator = separators
+
+    def _newline_indent(self):
+        return '\n' + (' ' * (self.indent * self.current_indent_level))
+
+    def _iterencode_list(self, lst, markers=None):
+        if not lst:
+            yield '[]'
+            return
+        if markers is not None:
+            markerid = id(lst)
+            if markerid in markers:
+                raise ValueError("Circular reference detected")
+            markers[markerid] = lst
+        yield '['
+        if self.indent is not None:
+            self.current_indent_level += 1
+            newline_indent = self._newline_indent()
+            separator = self.item_separator + newline_indent
+            yield newline_indent
+        else:
+            newline_indent = None
+            separator = self.item_separator
+        first = True
+        for value in lst:
+            if first:
+                first = False
+            else:
+                yield separator
+            for chunk in self._iterencode(value, markers):
+                yield chunk
+        if newline_indent is not None:
+            self.current_indent_level -= 1
+            yield self._newline_indent()
+        yield ']'
+        if markers is not None:
+            del markers[markerid]
+
+    def _iterencode_dict(self, dct, markers=None):
+        if not dct:
+            yield '{}'
+            return
+        if markers is not None:
+            markerid = id(dct)
+            if markerid in markers:
+                raise ValueError("Circular reference detected")
+            markers[markerid] = dct
+        yield '{'
+        key_separator = self.key_separator
+        if self.indent is not None:
+            self.current_indent_level += 1
+            newline_indent = self._newline_indent()
+            item_separator = self.item_separator + newline_indent
+            yield newline_indent
+        else:
+            newline_indent = None
+            item_separator = self.item_separator
+        first = True
+        if self.ensure_ascii:
+            encoder = encode_basestring_ascii
+        else:
+            encoder = encode_basestring
+        allow_nan = self.allow_nan
+        if self.sort_keys:
+            keys = dct.keys()
+            keys.sort()
+            items = [(k, dct[k]) for k in keys]
+        else:
+            items = dct.iteritems()
+        for key, value in items:
+            if isinstance(key, basestring):
+                pass
+            # JavaScript is weakly typed for these, so it makes sense to
+            # also allow them.  Many encoders seem to do something like this.
+            elif isinstance(key, float):
+                key = floatstr(key, allow_nan)
+            elif isinstance(key, (int, long)):
+                key = str(key)
+            elif key is True:
+                key = 'true'
+            elif key is False:
+                key = 'false'
+            elif key is None:
+                key = 'null'
+            elif self.skipkeys:
+                continue
+            else:
+                raise TypeError("key %r is not a string" % (key,))
+            if first:
+                first = False
+            else:
+                yield item_separator
+            yield encoder(key)
+            yield key_separator
+            for chunk in self._iterencode(value, markers):
+                yield chunk
+        if newline_indent is not None:
+            self.current_indent_level -= 1
+            yield self._newline_indent()
+        yield '}'
+        if markers is not None:
+            del markers[markerid]
+
+    def _iterencode(self, o, markers=None):
+        if isinstance(o, basestring):
+            if self.ensure_ascii:
+                encoder = encode_basestring_ascii
+            else:
+                encoder = encode_basestring
+            yield encoder(o)
+        elif o is None:
+            yield 'null'
+        elif o is True:
+            yield 'true'
+        elif o is False:
+            yield 'false'
+        elif isinstance(o, (int, long)):
+            yield str(o)
+        elif isinstance(o, float):
+            yield floatstr(o, self.allow_nan)
+        elif isinstance(o, (list, tuple)):
+            for chunk in self._iterencode_list(o, markers):
+                yield chunk
+        elif isinstance(o, dict):
+            for chunk in self._iterencode_dict(o, markers):
+                yield chunk
+        else:
+            if markers is not None:
+                markerid = id(o)
+                if markerid in markers:
+                    raise ValueError("Circular reference detected")
+                markers[markerid] = o
+            for chunk in self._iterencode_default(o, markers):
+                yield chunk
+            if markers is not None:
+                del markers[markerid]
+
+    def _iterencode_default(self, o, markers=None):
+        newobj = self.default(o)
+        return self._iterencode(newobj, markers)
+
+    def default(self, o):
+        """
+        Implement this method in a subclass such that it returns
+        a serializable object for ``o``, or calls the base implementation
+        (to raise a ``TypeError``).
+
+        For example, to support arbitrary iterators, you could
+        implement default like this::
+            
+            def default(self, o):
+                try:
+                    iterable = iter(o)
+                except TypeError:
+                    pass
+                else:
+                    return list(iterable)
+                return JSONEncoder.default(self, o)
+        """
+        raise TypeError("%r is not JSON serializable" % (o,))
+
+    def encode(self, o):
+        """
+        Return a JSON string representation of a Python data structure.
+
+        >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
+        '{"foo":["bar", "baz"]}'
+        """
+        # This doesn't pass the iterator directly to ''.join() because it
+        # sucks at reporting exceptions.  It's going to do this internally
+        # anyway because it uses PySequence_Fast or similar.
+        chunks = list(self.iterencode(o))
+        return ''.join(chunks)
+
+    def iterencode(self, o):
+        """
+        Encode the given object and yield each string
+        representation as available.
+        
+        For example::
+            
+            for chunk in JSONEncoder().iterencode(bigobject):
+                mysocket.write(chunk)
+        """
+        if self.check_circular:
+            markers = {}
+        else:
+            markers = None
+        return self._iterencode(o, markers)
+
+__all__ = ['JSONEncoder']
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/jsonfilter.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/jsonfilter.py
new file mode 100644
index 0000000000..d02ae2033a
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/jsonfilter.py
@@ -0,0 +1,40 @@
+from django.utils import simplejson
+import cgi
+
+class JSONFilter(object):
+    def __init__(self, app, mime_type='text/x-json'):
+        self.app = app
+        self.mime_type = mime_type
+
+    def __call__(self, environ, start_response):
+        # Read JSON POST input to jsonfilter.json if matching mime type
+        response = {'status': '200 OK', 'headers': []}
+        def json_start_response(status, headers):
+            response['status'] = status
+            response['headers'].extend(headers)
+        environ['jsonfilter.mime_type'] = self.mime_type
+        if environ.get('REQUEST_METHOD', '') == 'POST':
+            if environ.get('CONTENT_TYPE', '') == self.mime_type:
+                args = [_ for _ in [environ.get('CONTENT_LENGTH')] if _]
+                data = environ['wsgi.input'].read(*map(int, args))
+                environ['jsonfilter.json'] = simplejson.loads(data)
+        res = simplejson.dumps(self.app(environ, json_start_response))
+        jsonp = cgi.parse_qs(environ.get('QUERY_STRING', '')).get('jsonp')
+        if jsonp:
+            content_type = 'text/javascript'
+            res = ''.join(jsonp + ['(', res, ')'])
+        elif 'Opera' in environ.get('HTTP_USER_AGENT', ''):
+            # Opera has bunk XMLHttpRequest support for most mime types
+            content_type = 'text/plain'
+        else:
+            content_type = self.mime_type
+        headers = [
+            ('Content-type', content_type),
+            ('Content-length', len(res)),
+        ]
+        headers.extend(response['headers'])
+        start_response(response['status'], headers)
+        return [res]
+
+def factory(app, global_conf, **kw):
+    return JSONFilter(app, **kw)
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/scanner.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/scanner.py
new file mode 100644
index 0000000000..64f4999fb5
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/django/utils/simplejson/scanner.py
@@ -0,0 +1,63 @@
+"""
+Iterator based sre token scanner
+"""
+import sre_parse, sre_compile, sre_constants
+from sre_constants import BRANCH, SUBPATTERN
+from re import VERBOSE, MULTILINE, DOTALL
+import re
+
+__all__ = ['Scanner', 'pattern']
+
+FLAGS = (VERBOSE | MULTILINE | DOTALL)
+class Scanner(object):
+    def __init__(self, lexicon, flags=FLAGS):
+        self.actions = [None]
+        # combine phrases into a compound pattern
+        s = sre_parse.Pattern()
+        s.flags = flags
+        p = []
+        for idx, token in enumerate(lexicon):
+            phrase = token.pattern
+            try:
+                subpattern = sre_parse.SubPattern(s,
+                    [(SUBPATTERN, (idx + 1, sre_parse.parse(phrase, flags)))])
+            except sre_constants.error:
+                raise
+            p.append(subpattern)
+            self.actions.append(token)
+
+        p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
+        self.scanner = sre_compile.compile(p)
+
+
+    def iterscan(self, string, idx=0, context=None):
+        """
+        Yield match, end_idx for each match
+        """
+        match = self.scanner.scanner(string, idx).match
+        actions = self.actions
+        lastend = idx
+        end = len(string)
+        while True:
+            m = match()
+            if m is None:
+                break
+            matchbegin, matchend = m.span()
+            if lastend == matchend:
+                break
+            action = actions[m.lastindex]
+            if action is not None:
+                rval, next_pos = action(m, context)
+                if next_pos is not None and next_pos != matchend:
+                    # "fast forward" the scanner
+                    matchend = next_pos
+                    match = self.scanner.scanner(string, matchend).match
+                yield rval, matchend
+            lastend = matchend
+            
+def pattern(pattern, flags=FLAGS):
+    def decorator(fn):
+        fn.pattern = pattern
+        fn.regex = re.compile(pattern, flags)
+        return fn
+    return decorator
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/elemutil.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/elemutil.py
new file mode 100644
index 0000000000..ad971ba6ba
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/elemutil.py
@@ -0,0 +1,168 @@
+#  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.
+
+# Functions to help represent data as lists of elements and attributes
+
+from util import *
+
+element = "'element"
+attribute = "'attribute"
+atsign = "'@"
+
+# Return true if a value is an element
+def isElement(v):
+    if not isList(v) or isNil(v) or v == None or car(v) != element:
+        return False
+    return True
+
+# Return true if a value is an attribute
+def isAttribute(v):
+    if not isList(v) or isNil(v) or v == None or car(v) != attribute:
+        return False
+    return True
+
+# Return the name of attribute
+def attributeName(l):
+    return cadr(l)
+
+# Return the value of attribute
+def attributeValue(l):
+    return caddr(l)
+
+# Return the name of an element
+def elementName(l):
+    return cadr(l)
+
+# Return true if an element has children
+def elementHasChildren(l):
+    return not isNil(cddr(l))
+
+# Return the children of an element
+def elementChildren(l):
+    return cddr(l)
+
+# Return true if an element has a value
+def elementHasValue(l):
+    r = reverse(l)
+    if isSymbol(car(r)):
+        return False
+    if isList(car(r)) and not isNil(car(r)) and isSymbol(car(car(r))):
+        return False
+    return True
+
+# Return the value of an element
+def elementValue(l):
+    return car(reverse(l))
+
+# Convert an element to a value
+def elementToValueIsList(v):
+    if not isList(v):
+        return False
+    return isNil(v) or not isSymbol(car(v))
+
+def elementToValue(t):
+    if isTaggedList(t, attribute):
+        return (atsign + attributeName(t)[1:], attributeValue(t))
+    if isTaggedList(t, element):
+        if elementHasValue(t):
+            if not elementToValueIsList(elementValue(t)):
+                return (elementName(t), elementValue(t))
+            return cons(elementName(t), (elementsToValues(elementValue(t)),))
+        return cons(elementName(t), elementsToValues(elementChildren(t)))
+    if not isList(t):
+        return t
+    return elementsToValues(t)
+
+# Convert a list of elements to a list of values
+def elementToValueIsSymbol(v):
+    if not isList(v):
+        return False
+    if (isNil(v)):
+        return False
+    if not isSymbol(car(v)):
+        return False
+    return True
+
+def elementToValueGroupValues(v, l):
+    if isNil(l) or not elementToValueIsSymbol(v) or not elementToValueIsSymbol(car(l)):
+        return cons(v, l)
+    if car(car(l)) != car(v):
+        return cons(v, l)
+    if not elementToValueIsList(cadr(car(l))):
+        g = (car(v), (cdr(v), cdr(car(l))))
+        return elementToValueGroupValues(g, cdr(l))
+    g = (car(v), cons(cdr(v), cadr(car(l))))
+    return elementToValueGroupValues(g, cdr(l))
+
+def elementsToValues(e):
+    if isNil(e):
+        return e
+    return elementToValueGroupValues(elementToValue(car(e)), elementsToValues(cdr(e)))
+
+# Convert a value to an element
+def valueToElement(t):
+    if isList(t) and not isNil(t) and isSymbol(car(t)):
+        n = car(t)
+        v = cadr(t)
+        if not isList(v):
+            if n[0:2] == atsign:
+                return (attribute, n[1:], v)
+            return (element, n, v)
+        if isNil(v) or not isSymbol(car(v)):
+            return cons(element, cons(n, (valuesToElements(v),)))
+        return cons(element, cons(n, valuesToElements(cdr(t))))
+    if not isList(t):
+        return t
+    return valuesToElements(t)
+
+# Convert a list of values to a list of elements
+def valuesToElements(l):
+    if isNil(l):
+        return l
+    return cons(valueToElement(car(l)), valuesToElements(cdr(l)))
+
+# Return a selector lambda function which can be used to filter elements
+def evalSelect(s, v):
+    if isNil(s):
+        return True
+    if isNil(v):
+        return False
+    if car(s) != car(v):
+        return False
+    return evalSelect(cdr(s), cdr(v))
+
+def selector(s):
+    return lambda v: evalSelect(s, v)
+
+# Return the value of the attribute with the given name
+def namedAttributeValue(name, l):
+    f = filter(lambda v: isAttribute(v) and attributeName(v) == name, l)
+    if isNil(f):
+        return None
+    return caddr(car(f))
+
+# Return child elements with the given name
+def namedElementChildren(name, l):
+    return filter(lambda v: isElement(v) and elementName(v) == name, l)
+
+# Return the child element with the given name
+def namedElementChild(name, l):
+    f = namedElementChildren(name, l)
+    if isNil(f):
+        return None
+    return car(f)
+
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/invoker.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/invoker.py
new file mode 100644
index 0000000000..730e7c483f
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/invoker.py
@@ -0,0 +1,89 @@
+#!/usr/bin/python
+#  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.
+
+# Component invocation functions
+
+from sys import stderr, argv
+from util import *
+from jsonutil import *
+
+# JSON request id
+id = 1
+
+# Make a callable reference client
+class proxy:
+    def __init__(self, jpx):
+        self.jpx = jpx
+
+    def __call__(self, func, *args):
+
+        # Create a JSON-RPC request
+        global id
+        req = StringIO()
+        writeStrings(jsonRequest(id, func, args), req)
+        id = id + 1
+
+        # Eval the Java proxy
+        res = self.jpx.eval(req.getvalue())
+
+        # Extract result from JSON-RPC response
+        return jsonResultValue((res,))
+
+    def __repr__(self):
+        return repr((jpx,))
+
+def mkproxies(jpx):
+    if isNil(jpx):
+        return ()
+    return cons(proxy(car(jpx)), mkproxies(cdr(jpx)))
+
+# Make a callable component
+class component:
+    def __init__(self, name, impl, jpx):
+        self.name = name
+        self.impl = impl[0:len(impl) - 3]
+        self.mod = __import__(self.impl)
+        self.proxies = mkproxies(jpx)
+
+    def __call__(self, func, *args):
+        return self.mod.__getattribute__(func)(*(args + self.proxies))
+
+    def __repr__(self):
+        return repr((self.name, self.impl, self.mod, self.svcs, self.refs, self.props, self.proxies))
+
+# Converts the args received in a JSON request to a list of key value pairs
+def jsonArgs(a):
+    if isNil(a):
+        return ((),)
+    l = car(a);
+    return cons(l, jsonArgs(cdr(a)))
+
+# Apply a JSON function request to a component
+def apply(jsreq, comp):
+    json = elementsToValues(readJSON((jsreq,)))
+    args = jsonArgs(json)
+    jid = cadr(assoc("'id", args))
+    func = funcName(cadr(assoc("'method", args)))
+    params = cadr(assoc("'params", args))
+    v = comp(func, *params)
+    return jsonResult(jid, v)[0]
+
+# Make a component that can be called with a JSON function request
+def mkcomponent(name, impl, jpx):
+    comp = component(name, impl, jpx)
+    return lambda jsreq: apply(jsreq, comp)
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/jsonutil.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/jsonutil.py
new file mode 100644
index 0000000000..f69559de54
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/jsonutil.py
@@ -0,0 +1,142 @@
+#  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.
+
+# JSON data conversion functions
+
+try:
+    import json
+except:
+    from django.utils import simplejson as json
+
+from StringIO import StringIO
+from util import *
+from elemutil import *
+
+# Return true if a list represents a JS array
+def isJSArray(l):
+    if isNil(l):
+        return True
+    v = car(l)
+    if isSymbol(v):
+        return False
+    if isList(v):
+        if not isNil(v) and isSymbol(car(v)):
+            return False
+    return True
+
+# Converts JSON properties to values
+def jsPropertiesToValues(propertiesSoFar, o, i):
+    if isNil(i):
+        return propertiesSoFar
+    p = car(i)
+    jsv = o[p]
+    v = jsValToValue(jsv)
+
+    if isinstance(p, basestring):
+        n = str(p)
+        if n[0:1] == "@":
+            return jsPropertiesToValues(cons((attribute, "'" + n[1:], v), propertiesSoFar), o, cdr(i))
+        if isList(v) and not isJSArray(v):
+            return jsPropertiesToValues(cons(cons(element, cons("'" + n, v)), propertiesSoFar), o, cdr(i))
+        return jsPropertiesToValues(cons((element, "'" + n, v), propertiesSoFar), o, cdr(i))
+    return jsPropertiesToValues(cons(v, propertiesSoFar), o, cdr(i))
+
+# Converts a JSON val to a value
+def jsValToValue(jsv):
+    if isinstance(jsv, dict):
+        return jsPropertiesToValues((), jsv, tuple(jsv.keys()))
+    if isList(jsv):
+        return jsPropertiesToValues((), jsv, tuple(reversed(range(0, len(jsv)))))
+    if isinstance(jsv, basestring):
+        return str(jsv)
+    return jsv
+    
+# Convert a list of strings representing a JSON document to a list of values
+def readJSON(l):
+    s = StringIO()
+    writeStrings(l, s)
+    val = json.loads(s.getvalue())
+    return jsValToValue(val)
+
+# Convert a list of values to JSON array elements
+def valuesToJSElements(a, l, i):
+    if isNil(l):
+        return a
+    pv = valueToJSVal(car(l))
+    a[i] = pv
+    return valuesToJSElements(a, cdr(l), i + 1)
+    
+# Convert a value to a JSON value
+def valueToJSVal(v):
+    if not isList(v):
+        return v
+    if isJSArray(v):
+        return valuesToJSElements(list(range(0, len(v))), v, 0)
+    return valuesToJSProperties({}, v)
+
+# Convert a list of values to JSON properties
+def valuesToJSProperties(o, l):
+    if isNil(l):
+        return o
+    token = car(l)
+    if isTaggedList(token, attribute):
+        pv = valueToJSVal(attributeValue(token))
+        o["@" + attributeName(token)[1:]] = pv
+    elif isTaggedList(token, element):
+        if elementHasValue(token):
+            pv = valueToJSVal(elementValue(token))
+            o[elementName(token)[1:]] = pv
+        else:
+            child = {}
+            o[elementName(token)[1:]] = child
+            valuesToJSProperties(child, elementChildren(token))
+    return valuesToJSProperties(o, cdr(l))
+
+# Convert a list of values to a list of strings representing a JSON document
+def writeJSON(l):
+    jsv = valuesToJSProperties({}, l)
+    s = json.dumps(jsv, separators=(',',':'))
+    return (s,)
+
+# Convert a list + params to a JSON-RPC request
+def jsonRequest(id, func, params):
+    r = (("'id", id), ("'method", func), ("'params", params))
+    return writeJSON(valuesToElements(r))
+
+# Convert a value to a JSON-RPC result
+def jsonResult(id, val):
+    return writeJSON(valuesToElements((("'id", id), ("'result", val))))
+
+# Convert a JSON-RPC result to a value
+def jsonResultValue(s):
+    jsres = readJSON(s)
+    res = elementsToValues(jsres)
+    val = cadr(assoc("'result", res))
+    if isList(val) and not isJSArray(val):
+        return (val,)
+    return val
+
+# Return a portable function name from a JSON-RPC function name
+def funcName(f):
+    if f.startswith("."):
+        return f[1:]
+    if f.startswith("system."):
+        return f[7:]
+    if f.startswith("Service."):
+        return f[8:]
+    return f
+
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/rssutil.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/rssutil.py
new file mode 100644
index 0000000000..4f060d2321
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/rssutil.py
@@ -0,0 +1,119 @@
+#  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.
+
+# RSS data conversion functions
+
+from util import *
+from elemutil import *
+from xmlutil import *
+
+# Convert a list of elements to a list of values representing an RSS entry
+def entryElementsToValues(e):
+    lt = filter(selector((element, "'title")), e)
+    t = "" if isNil(lt) else elementValue(car(lt))
+    li = filter(selector((element, "'link")), e)
+    i = "" if isNil(li) else elementValue(car(li))
+    lc = filter(selector((element, "'description")), e)
+    return (t, i, elementValue(car(lc)))
+
+# Convert a list of elements to a list of values representing RSS entries
+def entriesElementsToValues(e):
+    if isNil(e):
+        return e
+    return cons(entryElementsToValues(car(e)), entriesElementsToValues(cdr(e)))
+
+# Convert a list of strings to a list of values representing an RSS entry
+def readRSSEntry(l):
+    e = readXML(l)
+    if isNil(e):
+        return ()
+    return entryElementsToValues(car(e))
+
+# Convert a list of values representy an RSS entry to a value
+def entryValue(e):
+    v = elementsToValues((caddr(e),))
+    return cons(car(e), (cadr(e), cdr(car(v))))
+
+# Return true if a list of strings represents an RSS feed
+def isRSSFeed(l):
+    if isNil(l):
+        return False
+    if car(l)[0:5] != "<?xml":
+        return False
+    return contains(car(l), "<rss")
+
+# Convert a list of strings to a list of values representing an RSS feed
+def readRSSFeed(l):
+    f = readXML(l)
+    if isNil(f):
+        return ()
+    c = filter(selector((element, "'channel")), car(f))
+    t = filter(selector((element, "'title")), car(c))
+    i = filter(selector((element, "'link")), car(c))
+    e = filter(selector((element, "'item")), car(c))
+    if isNil(e):
+        return (elementValue(car(t)), elementValue(car(i)))
+    return cons(elementValue(car(t)), cons(elementValue(car(i)), entriesElementsToValues(e)))
+
+# Convert an RSS feed containing elements to an RSS feed containing values
+def feedValuesLoop(e):
+    if (isNil(e)):
+        return e
+    return cons(entryValue(car(e)), feedValuesLoop(cdr(e)))
+
+def feedValues(e):
+    return cons(car(e), cons(cadr(e), feedValuesLoop(cddr(e))))
+
+# Convert a list of values representy an RSS entry to a list of elements
+def entryElement(l):
+    return (element, "'item",
+            (element, "'title", car(l)),
+            (element, "'link", cadr(l)),
+            (element, "'description", caddr(l)))
+
+# Convert a list of values representing RSS entries to a list of elements
+def entriesElements(l):
+    if isNil(l):
+        return l
+    return cons(entryElement(car(l)), entriesElements(cdr(l)))
+
+# Convert a list of values representing an RSS entry to an RSS entry
+def writeRSSEntry(l):
+    return writeXML((entryElement(l),), True)
+
+# Convert a list of values representing an RSS feed to an RSS feed
+def writeRSSFeed(l):
+    c = ((element, "'title", car(l)),
+            (element, "'link", cadr(l)),
+            (element, "'description", car(l)))
+    ce = c if isNil(cddr(l)) else append(c, entriesElements(cddr(l)))
+    fe = (element, "'rss", (attribute, "'version", "2.0"), append((element, "'channel"), ce))
+    return writeXML((fe,), True)
+
+# Convert an RSS entry containing a value to an RSS entry containing an item element
+def entryValuesToElements(v):
+    return cons(car(v), cons(cadr(v), valuesToElements((cons("'item", caddr(v)),))))
+
+# Convert an RSS feed containing values to an RSS feed containing elements
+def feedValuesToElementsLoop(v):
+    if isNil(v):
+        return v
+    return cons(entryValuesToElements(car(v)), feedValuesToElementsLoop(cdr(v)))
+
+def feedValuesToElements(v):
+    return cons(car(v), cons(cadr(v), feedValuesToElementsLoop(cddr(v))))
+
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/util.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/util.py
new file mode 100644
index 0000000000..560101e32d
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/util.py
@@ -0,0 +1,145 @@
+#  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.
+
+# Simple utility functions
+from sys import maxint
+
+# Scheme-like lists
+def cons(a, b):
+    return (a,) + b
+
+def car(l):
+    return l[0]
+
+def first(l):
+    return car(l)
+    
+def cdr(l):
+    return l[1:]
+
+def rest(l):
+    return cdr(l)
+
+def cadr(l):
+    return car(cdr(l))
+
+def cddr(l):
+    return cdr(cdr(l))
+
+def caddr(l):
+    return car(cddr(l))
+
+def append(a, b):
+    return a + b
+
+def reverse(l):
+    r = list(l)
+    r.reverse()
+    return tuple(r)
+
+def isNil(l):
+    if isinstance(l, streampair):
+        return l.isNil()
+    return l == ()
+
+def isSymbol(v):
+    return isinstance(v, basestring) and v[0:1] == "'"
+
+def isList(v):
+    if getattr(v, '__iter__', False) == False:
+        return False
+    if isinstance(v, basestring) or isinstance(v, dict):
+        return False
+    return True
+
+def isTaggedList(v, t):
+    return isList(v) and not isNil(v) and car(v) == t
+
+
+# Scheme-like streams
+class streampair(object):
+    def __init__(self, car, cdr):
+        self.car = car
+        self.cdr = cdr
+
+    def __repr__(self):
+        return repr(self[0:len(self)])
+
+    def isNil(self):
+        return self.cdr == ()
+
+    def __len__(self):
+        if self.cdr == ():
+            return 0
+        return 1 + len(self.cdr())
+
+    def __getitem__(self, i):
+        if i == 0:
+            return self.car
+        return self.cdr()[i - 1]
+
+    def __getslice__(self, i, j):
+        if isNil(self):
+            return ()
+        if i > 0:
+            if j == maxint:
+                return self.cdr()[i - 1: j]
+            return self.cdr()[i - 1: j - 1]
+        if j == maxint:
+            return self
+        if j == 0:
+            return (self.car,)
+        return (self.car,) + self.cdr()[: j - 1]
+
+    def __eq__(self, other):
+        sl = len(self)
+        ol = len(other)
+        if sl != ol:
+            return False
+        return self[0: sl] == other[0: ol]
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+def cons_stream(car, cdr):
+    return streampair(car, cdr)
+
+
+# Scheme-like associations
+def assoc(k, l):
+    if l == ():
+        return None
+
+    if k == car(car(l)):
+        return car(l)
+    return assoc(k, cdr(l))
+
+# Currying / partial function application
+def curry(f, *args):
+    return lambda *a: f(*(args + a))
+
+# Split a path into a list of segments
+def tokens(path):
+    return tuple(filter(lambda s: len(s) != 0, path.split("/")))
+
+# Write a list of strings to a stream
+def writeStrings(l, os):
+    if l == ():
+        return os
+    os.write(car(l))
+    return writeStrings(cdr(l), os)
+
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/xmlutil.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/xmlutil.py
new file mode 100644
index 0000000000..a1bc04629a
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/main/resources/xmlutil.py
@@ -0,0 +1,114 @@
+#  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.
+
+# XML handling functions
+
+from StringIO import StringIO
+from xml.parsers import expat
+import xml.etree.ElementTree as et
+from util import *
+from elemutil import *
+
+# Read a list of XML attributes
+def readAttributes(a):
+    if a == ():
+        return a
+    return cons((attribute, "'" + car(car(a)), cadr(car(a))), readAttributes(cdr(a)))
+
+# Read an XML element
+def readElement(e):
+    l = (element, "'" + e.tag) + readAttributes(tuple(e.items())) + readElements(tuple(e.getchildren()))
+    if e.text == None:
+        return l
+    return l + (e.text,)
+
+# Read a list of XML elements
+def readElements(l):
+    if l == ():
+        return l
+    return cons(readElement(car(l)), readElements(cdr(l)))
+
+# Parse a list of strings representing an XML document
+class NamespaceParser(et.XMLTreeBuilder):
+    def __init__(self):
+        et.XMLTreeBuilder.__init__(self)
+        self._parser = parser = expat.ParserCreate(None)
+        parser.DefaultHandlerExpand = self._default
+        parser.StartElementHandler = self._start
+        parser.EndElementHandler = self._end
+        parser.CharacterDataHandler = self._data
+        try:
+            parser.buffer_text = 1
+        except AttributeError:
+            pass
+        try:
+            parser.ordered_attributes = 1
+            parser.specified_attributes = 1
+            parser.StartElementHandler = self._start_list
+        except AttributeError:
+            pass
+
+def parseXML(l):
+    s = StringIO()
+    writeStrings(l, s)
+    parser = NamespaceParser()
+    parser.feed(s.getvalue())
+    return parser.close()
+
+# Read a list of values from a list of strings representing an XML document
+def readXML(l):
+    e = parseXML(l)
+    return (readElement(e),)
+
+# Write a list of XML element and attribute tokens
+def expandElementValues(n, l):
+    if isNil(l):
+        return l
+    return cons(cons(element, cons(n, car(l))), expandElementValues(n, cdr(l)))
+
+def writeList(l, xml):
+    if isNil(l):
+        return xml
+    token = car(l)
+    if isTaggedList(token, attribute):
+        xml.attrib[attributeName(token)[1:]] = str(attributeValue(token))
+    elif isTaggedList(token, element):
+        if elementHasValue(token):
+            v = elementValue(token)
+            if isList(v):
+                e = expandElementValues(elementName(token), v)
+                writeList(e, xml)
+            else:
+                child = et.Element(elementName(token)[1:])
+                writeList(elementChildren(token), child)
+                xml.append(child)
+        else:
+            child = et.Element(elementName(token)[1:])
+            writeList(elementChildren(token), child)
+            xml.append(child)
+    else:
+        xml.text = str(token)
+    writeList(cdr(l), xml)
+    return xml
+
+# Convert a list of values to a list of strings representing an XML document
+def writeXML(l, xmlTag):
+    e = writeList(l, [])
+    if not xmlTag:
+        return (et.tostring(car(e)),)
+    return (et.tostring(car(e), "UTF-8") + "\n",)
+
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/ClientTest.java b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/ClientTest.java
new file mode 100644
index 0000000000..301dfee78a
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/ClientTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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.    
+ */
+package org.apache.tuscany.sca.implementation.python.provider;
+
+import org.oasisopen.sca.annotation.Reference;
+
+
+/**
+ * Test Java component.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ClientTest implements EchoTest {
+	
+	@Reference
+	public EchoTest ref;
+
+	public String echo(final String s) {
+		return ref.echo(s);
+	}
+}
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/EchoTest.java b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/EchoTest.java
new file mode 100644
index 0000000000..88719a0ddc
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/EchoTest.java
@@ -0,0 +1,33 @@
+/*
+ * 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.    
+ */
+package org.apache.tuscany.sca.implementation.python.provider;
+
+import org.oasisopen.sca.annotation.Remotable;
+
+
+/**
+ * Test client interface.
+ * 
+ * @version $Rev$ $Date$
+ */
+@Remotable
+public interface EchoTest {
+
+	public String echo(String s);
+}
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/InvokeTestCase.java b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/InvokeTestCase.java
new file mode 100644
index 0000000000..2d8388b6d4
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/InvokeTestCase.java
@@ -0,0 +1,89 @@
+/*
+ * 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.    
+ */
+
+package org.apache.tuscany.sca.implementation.python.provider;
+
+import static org.apache.tuscany.sca.node.ContributionLocationHelper.getContributionLocation;
+import static org.junit.Assert.assertEquals;
+
+import org.apache.tuscany.sca.node.Contribution;
+import org.apache.tuscany.sca.node.Node;
+import org.apache.tuscany.sca.node.NodeFactory;
+import org.jabsorb.client.Client;
+import org.jabsorb.client.Session;
+import org.jabsorb.client.TransportRegistry;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * Tests the Python implementation provider.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class InvokeTestCase {
+	static Node node;
+    
+    @BeforeClass
+    public static void setUp() throws Exception {
+    	try {
+	    	final String loc = getContributionLocation("domain-test.composite");
+			node = NodeFactory.newInstance().createNode("domain-test.composite", new Contribution("c", loc));
+	        node.start();
+    	} catch (Exception e) {
+    		e.printStackTrace();
+    	}
+    }
+
+    @AfterClass
+    public static void tearDown() throws Exception {
+    	node.stop();
+    }
+
+    @Test
+    public void testService() throws Exception {
+        final Session s = TransportRegistry.i().createSession("http://localhost:8085/python");
+        final Client c = new Client(s);
+        final Object px = c.openProxy("", EchoTest.class);
+        final Object r = c.invoke(px, EchoTest.class.getMethod("echo", String.class), new Object[]{"Hey"});
+        c.closeProxy(px);
+        s.close();
+        assertEquals("Hey", r);
+    }
+
+    @Test
+    public void testReference() throws Exception {
+        final Session s = TransportRegistry.i().createSession("http://localhost:8085/client");
+        final Client c = new Client(s);
+        final Object px = c.openProxy("", EchoTest.class);
+        final Object r = c.invoke(px, EchoTest.class.getMethod("echo", String.class), new Object[]{"Hey"});
+        c.closeProxy(px);
+        s.close();
+        assertEquals("Hey", r);
+    }
+
+    //@Test Disabled for now as Java / JSON databinding transform doesn't seem
+    // to produce the right JSON
+    public void testLocal() throws Exception {
+    	final EchoTest s = node.getService(EchoTest.class, "java-client-test");
+    	final String r = s.echo("Hey");
+        assertEquals("Hey", r);
+    }
+
+}
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/ServerTest.java b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/ServerTest.java
new file mode 100644
index 0000000000..36e4f18f64
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/java/org/apache/tuscany/sca/implementation/python/provider/ServerTest.java
@@ -0,0 +1,32 @@
+/*
+ * 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.    
+ */
+package org.apache.tuscany.sca.implementation.python.provider;
+
+
+/**
+ * Test Java component.
+ * 
+ * @version $Rev$ $Date$
+ */
+public class ServerTest implements EchoTest {
+
+	public String echo(final String s) {
+		return s;
+	}
+}
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/resources/client_test.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/resources/client_test.py
new file mode 100644
index 0000000000..47e6cf4bda
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/resources/client_test.py
@@ -0,0 +1,35 @@
+#  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.
+
+# JSON-RPC test case
+
+def echo(x, ref):
+    return ref("echo", x)
+
+# ATOMPub test case
+
+def get(id, ref):
+    return ref("get", id)
+
+def post(collection, item, ref):
+    return ref("post", collection, item)
+
+def put(id, item, ref):
+    return ref("put", id, item)
+
+def delete(id, ref):
+    return ref("delete", id)
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/resources/domain-test.composite b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/resources/domain-test.composite
new file mode 100644
index 0000000000..7f7a82dcd4
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/resources/domain-test.composite
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * 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.    
+-->
+<composite xmlns="http://docs.oasis-open.org/ns/opencsa/sca/200912"
+  xmlns:t="http://tuscany.apache.org/xmlns/sca/1.1"
+  targetNamespace="http://domain/test"
+  name="domain-test">
+        
+    <component name="python-test">
+        <t:implementation.python script="server_test.py"/>
+        <service name="test">
+            <t:binding.jsonrpc uri="http://localhost:8085/python"/>
+        </service>
+    </component>     
+
+    <component name="client-test">
+        <t:implementation.python script="client_test.py"/>
+        <service name="client">
+            <t:binding.jsonrpc uri="http://localhost:8085/client"/>
+        </service>
+        <reference name="ref" target="python-test">
+        </reference>
+    </component>
+
+    <component name="local-java-test">
+        <implementation.java class="org.apache.tuscany.sca.implementation.python.provider.ServerTest"/>
+    </component>
+
+    <component name="local-client-test">
+        <t:implementation.python script="client_test.py"/>
+        <reference name="ref" target="local-java-test">
+        </reference>
+    </component>
+
+    <component name="java-client-test">
+        <implementation.java class="org.apache.tuscany.sca.implementation.python.provider.ClientTest"/>
+        <reference name="ref" target="local-client-test">
+        </reference>
+    </component>
+
+</composite>
diff --git a/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/resources/server_test.py b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/resources/server_test.py
new file mode 100644
index 0000000000..dcda763043
--- /dev/null
+++ b/sandbox/sebastien/java/dynamic/modules/implementation-python-runtime/src/test/resources/server_test.py
@@ -0,0 +1,42 @@
+#  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.
+
+# JSON-RPC test case
+
+def echo(x):
+    return x
+
+# ATOMPub test case
+
+def get(id):
+    if id == ():
+        return ("Sample Feed", "123456789",
+            ("Item", "111", (("'javaClass", "services.Item"), ("'name", "Apple"), ("'currencyCode", "USD"), ("'currencySymbol", "$"), ("'price", 2.99))),
+            ("Item", "222", (("'javaClass", "services.Item"), ("'name", "Orange"), ("'currencyCode", "USD"), ("'currencySymbol", "$"), ("'price", 3.55))),
+            ("Item", "333", (("'javaClass", "services.Item"), ("name", "Pear"), ("'currencyCode", "USD"), ("'currencySymbol", "$"), ("'price", 1.55))))
+        
+    entry = (("'javaClass", "services.Item"), ("'name", "Apple"), ("'currencyCode", "USD"), ("'currencySymbol", "$"), ("'price", 2.99))
+    return ("Item", id[0], entry)
+
+def post(collection, item):
+    return ("123456789",)
+
+def put(id, item):
+    return True
+
+def delete(id):
+    return True
diff --git a/sandbox/sebastien/java/dynamic/modules/pom.xml b/sandbox/sebastien/java/dynamic/modules/pom.xml
index a4716680d7..7b58974616 100644
--- a/sandbox/sebastien/java/dynamic/modules/pom.xml
+++ b/sandbox/sebastien/java/dynamic/modules/pom.xml
@@ -140,6 +140,9 @@
         <module>binding-corba</module>
         <module>binding-corba-runtime</module>
 
+        <module>implementation-python</module>
+        <module>implementation-python-runtime</module>
+
         <module>implementation-script</module>
         <module>implementation-script-runtime</module>
         <module>implementation-jaxrs</module>