package nodebox.node;

import nodebox.graphics.CanvasContext;

import org.python.core.*;

import org.python.util.PythonInterpreter;

import java.io.File;

import java.io.PrintStream;

import java.util.Locale;

/**

* Python source code is in this form:

* <pre><code>

* def cook(self):

* return Polygon.rect(self.x, self.y, self.width, self.height)

* </code></pre>

* <p/>

* Self is a reference that points to a node access proxy that allows direct access to the node's parameter values.

* You can access the node object using "self.node".

* <p/>

* When creating a PythonCode object, it is executed immediately to extract the "cook" function. Source code

* that has no or invalid "cook" function will throw an IllegalArgumentException.

* <p/>

* The cook method on this class executes the Python "cook" function with the self reference. It also sets a number

* of global parameters based on the ProcessingContext.

*/

public class PythonCode implements NodeCode {

public static final String TYPE = "python";

private String source;

private PyCode code;

private PyDictionary namespace;

private PyFunction cookFunction;

private CanvasContext ctx;

static {

// Monkey patch to facilitate access to a node's prototype cook code.

PythonInterpreter interpreter = new PythonInterpreter();

interpreter.exec("from nodebox.node import Node, PythonCode\n" +

"_cook = Node.cook\n" +

"def cook(self, *args):\n" +

" if len(args) == 1 and isinstance(args[0], PythonCode.SelfWrapper):\n" +

" wrapper = args[0]\n" +

" return self.asCode(\"_code\").cook(wrapper.node, wrapper.context)\n" +

" else:\n" +

" return _cook(self, *args)\n" +

"Node.cook = cook");

}

public PythonCode(String source) {

this.source = source;

namespace = new PyDictionary();

}

private void preCook() {

// The namespace will remain bound to the interpreter.

// Changes to this dictionary will affect the namespace of the interpreter.

PythonInterpreter interpreter = new PythonInterpreter(namespace);

// Immediately run the code to extract the cook(self) method.

interpreter.exec("from nodebox1.graphics import Context\n" +

"_g = globals()\n" +

"_ctx = Context(ns=_g)\n" +

"for n in dir(_ctx):\n" +

" _g[n] = getattr(_ctx, n)");

if (code == null)

code = new PythonInterpreter().compile(source);

interpreter.exec(code);

ctx = (CanvasContext) interpreter.get("_ctx").__tojava__(CanvasContext.class);

try {

cookFunction = (PyFunction) interpreter.get("cook");

//if (cookFunction == null)

// throw new RuntimeException("Source code does not contain a function \"cook(self)\".");

} catch (ClassCastException e) {

throw new RuntimeException("Attribute \"cook\" in source code is not a function.");

}

// We cannot check if the function takes only one (required) argument.

// If the function has more arguments, this will throw an error when cooking.

}

public Object cook(Node node, ProcessingContext context) throws RuntimeException {

// Reassign the output and error streams.

PrintStream oldOutStream = System.out;

PrintStream oldErrStream = System.err;

System.setOut(context.getOutputStream());

System.setErr(context.getErrorStream());

PySystemState ss = Py.getSystemState();

PyObject oldStdout = ss.stdout;

PyObject oldStderr = ss.stderr;

ss.stdout = Py.java2py(context.getOutputStream());

ss.stderr = Py.java2py(context.getErrorStream());

// Set the current working directory.

File libraryFile = null;

if (node != null && node.getLibrary() != null) {

libraryFile = node.getLibrary().getFile();

}

String originalWorkingDir = null;

if (libraryFile != null) {

originalWorkingDir = Py.getSystemState().getCurrentWorkingDir();

Py.getSystemState().setCurrentWorkingDir(libraryFile.getParent());

}

// Run the Python function.

PyObject pyResult = null;

try {

PyObject self;

if (node == null) {

self = Py.None;

} else {

self = new SelfWrapper(node, context);

}

// Add globals into the function namespace.

namespace.put("context", context);

namespace.put("node", self);

namespace.put("FRAME", context.getFrame());

if (ctx != null)

ctx.getCanvas().clear();

if (cookFunction == null) preCook();

if (cookFunction != null) {

pyResult = cookFunction.__call__(self);

}

} finally {

// Reset the output streams.

System.setOut(oldOutStream);

System.setErr(oldErrStream);

ss.stdout = oldStdout;

ss.stderr = oldStderr;

}

// Unwrap the result.

Object result;

if (pyResult != null) {

result = pyResult.__tojava__(Object.class);

if (result == Py.NoConversion) {

throw new RuntimeException("Cannot convert Python object " + pyResult + " to java.");

}

} else {

CanvasContext g = null;

try {

g = (CanvasContext) namespace.get("_ctx");

result = g.getCanvas().asGeometry();

} catch (ClassCastException e) {

result = null;

}

}

// Reset the current working directory.

if (originalWorkingDir != null) {

Py.getSystemState().setCurrentWorkingDir(originalWorkingDir);

}

return result;

}

public String getSource() {

return source;

}

public String getType() {

return TYPE;

}

/**

* The self wrapper allows easy access to parameter values from the node.

* Instead of doing node.asString("someparameter"), you can use self.someparameter.

* You can also access the node itself by querying self.node.

* <p/>

* The code here looks similar to the NodeAccessProxy, but it is not the same. Specifically, we don't give users

* easy access to parameters/ports on other nodes. In principle, all the behaviour of the

* node should be self-contained, which means that everything the node needs to operate is set in its parameters

* and ports. Therefore it should not have access to other nodes. For nodes that implement special functionality

* (such as the copy node), they can still access everything through the node reference.

*/

public class SelfWrapper extends PyObject {

private Node node;

private ProcessingContext context;

public SelfWrapper(Node node, ProcessingContext context) {

this.node = node;

this.context = context;

}

@Override

public PyObject __findattr_ex__(String name) {

if ("node".equals(name)) return Py.java2py(node);

if ("context".equals(name)) return Py.java2py(context);

Parameter p = node.getParameter(name);

if (p == null) {

Port port = node.getPort(name);

if (port == null) {

// This will throw an error that we explicitly do not catch.

noParameterOrPortError(name);

throw new AssertionError("noParameterOrPortError method should have thrown an error.");

} else {

if (port.getCardinality() == Port.Cardinality.SINGLE) {

return Py.java2py(port.getValue());

} else {

return Py.java2py(port.getValues());

}

}

} else {

return Py.java2py(p.getValue());

}

}

/**

* This method throws an error that will be shown to users referring to non-existant parameters.

* (e.g. self.inventedParameter)

* <p/>

* We could use the original noAttributeError, but that results in an ugly object name (a reference

* to this proxy class). We'd much rather refer to the node identifier and parameter/port.

*

* @param name the name of the parameter

*/

public void noParameterOrPortError(String name) {

throw Py.AttributeError(String.format(Locale.US, "Node '%.50s' has no parameter or port '%.400s'",

node.getIdentifier(), name));

}

}

}