sys.stdin. This
* stream is used in a byte-oriented way, through calls to read and
* readline on the object.
*
* @param inStream a Python file-like object to use as the input stream
*/
public void setIn(PyObject inStream) {
getSystemState().stdin = inStream;
}
/**
* Sets a {@link Reader} to use for the standard input stream, sys.stdin. This
* stream is wrapped such that characters will be narrowed to bytes. A character greater than
* U+00FF will raise a Java IllegalArgumentException from within
* {@link PyString}.
*
* @param inStream to use as the input stream
*/
public void setIn(java.io.Reader inStream) {
setIn(new PyFileReader(inStream));
}
/**
* Sets a {@link java.io.InputStream} to use for the standard input stream.
*
* @param inStream InputStream to use as input stream
*/
public void setIn(java.io.InputStream inStream) {
setIn(new PyFile(inStream));
}
/**
* Sets a Python object to use for the standard output stream, sys.stdout. This
* stream is used in a byte-oriented way (mostly) that depends on the type of file-like object.
* The behaviour as implemented is:
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
* Python type of object o written | |||
str/bytes | unicode | Any other type | |
|---|---|---|---|
| {@link PyFile} | as bytes directly | respect {@link PyFile#encoding} | call str(o) first |
| {@link PyFileWriter} | each byte value as a char | write as Java chars | call o.toString() first |
Other {@link PyObject} f | invoke f.write(str(o)) | invoke f.write(o) | invoke f.write(str(o)) |
sys.stdout.
* The behaviour as implemented is to output each object o by calling
* o.toString() and writing this as UTF-16.
*
* @param outStream to use as the output stream
*/
public void setOut(java.io.Writer outStream) {
setOut(new PyFileWriter(outStream));
}
/**
* Sets a {@link java.io.OutputStream} to use for the standard output stream.
*
* @param outStream OutputStream to use as output stream
*/
public void setOut(java.io.OutputStream outStream) {
setOut(new PyFile(outStream));
}
/**
* Sets a Python object to use for the standard output stream, sys.stderr. This
* stream is used in a byte-oriented way (mostly) that depends on the type of file-like object,
* in the same way as {@link #setOut(PyObject)}.
*
* @param outStream Python file-like object to use as the error output stream
*/
public void setErr(PyObject outStream) {
getSystemState().stderr = outStream;
}
/**
* Sets a {@link java.io.Writer} to use for the standard output stream, sys.stdout.
* The behaviour as implemented is to output each object o by calling
* o.toString() and writing this as UTF-16.
*
* @param outStream to use as the error output stream
*/
public void setErr(java.io.Writer outStream) {
setErr(new PyFileWriter(outStream));
}
public void setErr(java.io.OutputStream outStream) {
setErr(new PyFile(outStream));
}
/**
* Evaluates a string as a Python expression and returns the result.
*/
public PyObject eval(String s) {
setSystemState();
return __builtin__.eval(new PyString(s), getLocals());
}
/**
* Evaluates a Python code object and returns the result.
*/
public PyObject eval(PyObject code) {
setSystemState();
return __builtin__.eval(code, getLocals());
}
/**
* Executes a string of Python source in the local namespace.
*
* In some environments, such as Windows, Unicode characters in the script will be converted
* into ascii question marks (?). This can be avoided by first compiling the fragment using
* PythonInterpreter.compile(), and using the overridden form of this method which takes a
* PyCode object. Code page declarations are not supported.
*/
public void exec(String s) {
setSystemState();
Py.exec(Py.compile_flags(s, "