weka.core.scripting.Jython Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of weka-stable Show documentation
Show all versions of weka-stable Show documentation
The Waikato Environment for Knowledge Analysis (WEKA), a machine
learning workbench. This is the stable version. Apart from bugfixes, this version
does not receive any other updates.
/*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see currentPaths;
String filename;
Object interpreter;
result = null;
if (!isPresent()) {
return result;
}
interpreter = newInterpreter();
if (interpreter == null) {
return result;
}
// add paths to sys.path
if (paths.length > 0) {
invoke(interpreter, "exec", new Class[] { String.class },
new Object[] { "import sys" });
// determine currently set paths
instanceName = "syspath";
invoke(interpreter, "exec", new Class[] { String.class },
new Object[] { instanceName + " = sys.path" });
currentPaths = new HashSet();
try {
tmpPaths = (String[]) invoke(interpreter, "get", new Class[] {
String.class, Class.class }, new Object[] { instanceName,
String[].class });
for (i = 0; i < tmpPaths.length; i++) {
currentPaths.add(tmpPaths[i]);
}
} catch (Exception ex) {
ex.printStackTrace();
}
// add only new paths
for (i = 0; i < paths.length; i++) {
if (!currentPaths.contains(paths[i].getAbsolutePath())) {
invoke(interpreter, "exec", new Class[] { String.class },
new Object[] { "sys.path.append('" + paths[i].getAbsolutePath()
+ "')" });
}
}
}
// get object
filename = file.getAbsolutePath();
invoke(interpreter, "execfile", new Class[] { String.class },
new Object[] { filename });
tempName = filename.substring(filename.lastIndexOf("/") + 1);
tempName = tempName.substring(0, tempName.indexOf("."));
instanceName = tempName.toLowerCase();
javaClassName = tempName.substring(0, 1).toUpperCase()
+ tempName.substring(1);
objectDef = "=" + javaClassName + "()";
invoke(interpreter, "exec", new Class[] { String.class },
new Object[] { instanceName + objectDef });
try {
result = invoke(interpreter, "get", new Class[] { String.class,
Class.class }, new Object[] { instanceName, template });
} catch (Exception ex) {
ex.printStackTrace();
}
return result;
}
/**
* executes the specified method and returns the result, if any
*
* @param o the object the method should be called from, e.g., a Python
* Interpreter
* @param methodName the name of the method
* @param paramClasses the classes of the parameters
* @param paramValues the values of the parameters
* @return the return value of the method, if any (in that case null)
*/
public static Object invoke(Object o, String methodName,
Class[] paramClasses, Object[] paramValues) {
Method m;
Object result;
result = null;
try {
m = o.getClass().getMethod(methodName, paramClasses);
result = m.invoke(o, paramValues);
} catch (Exception e) {
e.printStackTrace();
result = null;
}
return result;
}
/**
* deserializes the Python Object from the stream
*
* @param in the stream to use
* @return the deserialized object
*/
public static Object deserialize(InputStream in) {
Class cls;
Class[] paramTypes;
Constructor constr;
Object[] arglist;
Object obj;
Object result;
result = null;
try {
cls = Class.forName(CLASS_PYTHONOBJECTINPUTSTREAM);
paramTypes = new Class[] { InputStream.class };
constr = cls.getConstructor(paramTypes);
arglist = new Object[] { in };
obj = constr.newInstance(arglist);
result = invoke(obj, "readObject", new Class[] {}, new Object[] {});
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* Returns the revision string.
*
* @return the revision
*/
@Override
public String getRevision() {
return RevisionUtils.extract("$Revision: 10203 $");
}
/**
* If no arguments are given, it just prints the presence of the Jython
* classes, otherwise it expects a Jython filename to execute.
*
* @param args commandline arguments
*/
public static void main(String[] args) {
if (args.length == 0) {
System.out.println("Jython present: " + isPresent());
} else {
Jython jython = new Jython();
if (jython.getInterpreter() == null) {
System.err.println("Cannot instantiate Python Interpreter!");
} else {
jython.invoke("execfile", new Class[] { String.class },
new Object[] { args[0] });
}
}
}
}