static class SingletonResolver implements Serializable {

private String which;

SingletonResolver(String which) {

this.which = which;

}

private Object readResolve() throws ObjectStreamException {

if (which.equals("None")) {

return Py.None;

} else if (which.equals("Ellipsis")) {

return Py.Ellipsis;

} else if (which.equals("NotImplemented")) {

return Py.NotImplemented;

}

throw new StreamCorruptedException("unknown singleton: " + which);

}

}

/* Holds the singleton None and Ellipsis objects */

/** The singleton None Python object **/

public final static PyObject None = PyNone.getInstance();

/** The singleton Ellipsis Python object - written as ... when indexing */

public final static PyObject Ellipsis = new PyEllipsis();

/** The singleton NotImplemented Python object. Used in rich comparison */

public final static PyObject NotImplemented = new PyNotImplemented();

/** A zero-length array of Strings to pass to functions that

public final static String[] NoKeywords = new String[0];

/** A zero-length array of PyObject's to pass to functions when we have no arguments **/

public final static PyObject[] EmptyObjects = new PyObject[0];

/** A frozenset with zero elements **/

public final static PyFrozenSet EmptyFrozenSet = new PyFrozenSet();

/** A tuple with zero elements **/

public final static PyTuple EmptyTuple = new PyTuple(Py.EmptyObjects);

/** The Python integer 0 **/

public final static PyInteger Zero = new PyInteger(0);

/** The Python integer 1 **/

public final static PyInteger One = new PyInteger(1);

/** The Python boolean False **/

public final static PyBoolean False = new PyBoolean(false);

/** The Python boolean True **/

public final static PyBoolean True = new PyBoolean(true);

/** A zero-length Python byte string **/

public final static PyString EmptyString = PyString.fromInterned("");

/** A zero-length Python Unicode string **/

public final static PyUnicode EmptyUnicode = new PyUnicode("");

/** A Python string containing '\n' **/

public final static PyString Newline = PyString.fromInterned("\n");

/** A Python unicode string containing '\n' **/

public final static PyUnicode UnicodeNewline = new PyUnicode("\n");

/** A Python string containing ' ' **/

public final static PyString Space = PyString.fromInterned(" ");

/** A Python unicode string containing ' ' **/

public final static PyUnicode UnicodeSpace = new PyUnicode(" ");

/** Set if the type object is dynamically allocated */

public final static long TPFLAGS_HEAPTYPE = 1L << 9;

/** Set if the type allows subclassing */

public final static long TPFLAGS_BASETYPE = 1L << 10;

/** Type is abstract and cannot be instantiated */

public final static long TPFLAGS_IS_ABSTRACT = 1L << 20;

/** A unique object to indicate no conversion is possible

public final static Object NoConversion = new PySingleton("Error");

public static PyObject OSError;

public static PyException OSError(String message) {

return new PyException(Py.OSError, message);

}

public static PyException OSError(IOException ioe) {

return fromIOException(ioe, Py.OSError);

}

public static PyException OSError(Constant errno) {

int value = errno.intValue();

PyObject args = new PyTuple(Py.newInteger(value), PosixModule.strerror(value));

return new PyException(Py.OSError, args);

}

public static PyException OSError(Constant errno, PyObject filename) {

int value = errno.intValue();

// see https://github.com/jruby/jruby/commit/947c661e46683ea82f8016dde9d3fa597cd10e56

// for rationale to do this mapping, but in a nutshell jnr-constants is automatically

// generated from header files, so that's not the right place to do this mapping,

// but for Posix compatibility reasons both CPython andCRuby do this mapping;

// except CPython chooses EEXIST instead of CRuby's ENOENT

if (Platform.IS_WINDOWS && (value == 20047 || value == Errno.ESRCH.intValue())) {

value = Errno.EEXIST.intValue();

}

// Pass to strerror because jnr-constants currently lacks Errno descriptions on

// Windows, and strerror falls back to Linux's

PyObject args = new PyTuple(Py.newInteger(value), PosixModule.strerror(value), filename);

return new PyException(Py.OSError, args);

}

public static PyObject NotImplementedError;

public static PyException NotImplementedError(String message) {

return new PyException(Py.NotImplementedError, message);

}

public static PyObject EnvironmentError;

public static PyException EnvironmentError(String message) {

return new PyException(Py.EnvironmentError, message);

}

/* The standard Python exceptions */

public static PyObject OverflowError;

public static PyException OverflowError(String message) {

return new PyException(Py.OverflowError, message);

}

public static PyObject RuntimeError;

public static PyException RuntimeError(String message) {

return new PyException(Py.RuntimeError, message);

}

public static PyObject KeyboardInterrupt;

public static PyException KeyboardInterrupt(String message) {

return new PyException(Py.KeyboardInterrupt, message);

}

public static PyObject FloatingPointError;

public static PyException FloatingPointError(String message) {

return new PyException(Py.FloatingPointError, message);

}

public static PyObject SyntaxError;

public static PyException SyntaxError(String message) {

return new PyException(Py.SyntaxError, message);

}

public static PyObject IndentationError;

public static PyObject TabError;

public static PyObject AttributeError;

public static PyException AttributeError(String message) {

return new PyException(Py.AttributeError, message);

}

public static PyObject IOError;

public static PyException IOError(IOException ioe) {

return fromIOException(ioe, Py.IOError);

}

public static PyException IOError(String message) {

return new PyException(Py.IOError, message);

}

public static PyException IOError(Constant errno) {

int value = errno.intValue();

PyObject args = new PyTuple(Py.newInteger(value), PosixModule.strerror(value));

return new PyException(Py.IOError, args);

}

public static PyException IOError(Constant errno, String filename) {

return IOError(errno, Py.fileSystemEncode(filename));

}

public static PyException IOError(Constant errno, PyObject filename) {

int value = errno.intValue();

PyObject args = new PyTuple(Py.newInteger(value), PosixModule.strerror(value), filename);

return new PyException(Py.IOError, args);

}

private static PyException fromIOException(IOException ioe, PyObject err) {

String message = ioe.getMessage();

if (message == null) {

message = ioe.getClass().getName();

}

if (ioe instanceof FileNotFoundException) {

PyTuple args = new PyTuple(Py.newInteger(Errno.ENOENT.intValue()),

Py.newStringOrUnicode("File not found - " + message));

return new PyException(err, args);

}

return new PyException(err, message);

}

public static PyObject KeyError;

public static PyException KeyError(String message) {

return new PyException(Py.KeyError, message);

}

public static PyException KeyError(PyObject key) {

return new PyException(Py.KeyError, key);

}

public static PyObject AssertionError;

public static PyException AssertionError(String message) {

return new PyException(Py.AssertionError, message);

}

public static PyObject TypeError;

public static PyException TypeError(String message) {

return new PyException(Py.TypeError, message);

}

public static PyObject ReferenceError;

public static PyException ReferenceError(String message) {

return new PyException(Py.ReferenceError, message);

}

public static PyObject SystemError;

public static PyException SystemError(String message) {

return new PyException(Py.SystemError, message);

}

public static PyObject IndexError;

public static PyException IndexError(String message) {

return new PyException(Py.IndexError, message);

}

public static PyObject ZeroDivisionError;

public static PyException ZeroDivisionError(String message) {

return new PyException(Py.ZeroDivisionError, message);

}

public static PyObject NameError;

public static PyException NameError(String message) {

return new PyException(Py.NameError, message);

}

public static PyObject UnboundLocalError;

public static PyException UnboundLocalError(String message) {

return new PyException(Py.UnboundLocalError, message);

}

public static PyObject SystemExit;

static void maybeSystemExit(PyException exc) {

if (exc.match(Py.SystemExit)) {

// No actual exit here if Options.interactive (-i flag) is in force.

handleSystemExit(exc);

}

}

/**

static void handleSystemExit(PyException exc) {

if (!Options.inspect) {

PyObject value = exc.value;

if (PyException.isExceptionInstance(exc.value)) {

value = value.__findattr__("code");

}

// Decide exit status and produce message while Jython still works

int exitStatus;

if (value instanceof PyInteger) {

exitStatus = ((PyInteger) value).getValue();

} else {

if (value != Py.None) {

try {

Py.println(value);

exitStatus = 1;

} catch (Throwable t) {

exitStatus = 0;

}

} else {

exitStatus = 0;

}

}

// Shut down Jython

PySystemState sys = Py.getSystemState();

sys.callExitFunc();

sys.close();

System.exit(exitStatus);

}

}

public static PyObject StopIteration;

public static PyException StopIteration(String message) {

return new PyException(Py.StopIteration, message);

}

public static PyObject GeneratorExit;

public static PyException GeneratorExit(String message) {

return new PyException(Py.GeneratorExit, message);

}

public static PyObject ImportError;

public static PyException ImportError(String message) {

return new PyException(Py.ImportError, message);

}

public static PyObject ValueError;

public static PyException ValueError(String message) {

return new PyException(Py.ValueError, message);

}

public static PyObject UnicodeError;

public static PyException UnicodeError(String message) {

return new PyException(Py.UnicodeError, message);

}

public static PyObject UnicodeTranslateError;

public static PyException UnicodeTranslateError(String object,

int start,

int end, String reason) {

return new PyException(Py.UnicodeTranslateError, new PyTuple(new PyString(object),

new PyInteger(start),

new PyInteger(end),

new PyString(reason)));

}

public static PyObject UnicodeDecodeError;

public static PyException UnicodeDecodeError(String encoding,

String object,

int start,

int end,

String reason) {

return new PyException(Py.UnicodeDecodeError, new PyTuple(new PyString(encoding),

new PyString(object),

new PyInteger(start),

new PyInteger(end),

new PyString(reason)));

}

public static PyObject UnicodeEncodeError;

public static PyException UnicodeEncodeError(String encoding,

String object,

int start,

int end,

String reason) {

return new PyException(Py.UnicodeEncodeError, new PyTuple(new PyString(encoding),

new PyUnicode(object),

new PyInteger(start),

new PyInteger(end),

new PyString(reason)));

}

public static PyObject EOFError;

public static PyException EOFError(String message) {

return new PyException(Py.EOFError, message);

}

public static PyObject MemoryError;

public static void memory_error(OutOfMemoryError t) {

if (Options.showJavaExceptions) {

t.printStackTrace();

}

}

public static PyException MemoryError(String message) {

return new PyException(Py.MemoryError, message);

}

public static PyObject BufferError;

public static PyException BufferError(String message) {

return new PyException(Py.BufferError, message);

}

public static PyObject ArithmeticError;

public static PyObject LookupError;

public static PyObject StandardError;

public static PyObject Exception;

public static PyObject BaseException;

public static PyObject Warning;

public static void Warning(String message) {

warning(Warning, message);

}

public static PyObject UserWarning;

public static void UserWarning(String message) {

warning(UserWarning, message);

}

public static PyObject DeprecationWarning;

public static void DeprecationWarning(String message) {

warning(DeprecationWarning, message);

}

public static PyObject PendingDeprecationWarning;

public static void PendingDeprecationWarning(String message) {

warning(PendingDeprecationWarning, message);

}

public static PyObject SyntaxWarning;

public static void SyntaxWarning(String message) {

warning(SyntaxWarning, message);

}

public static PyObject RuntimeWarning;

public static void RuntimeWarning(String message) {

warning(RuntimeWarning, message);

}

public static PyObject FutureWarning;

public static void FutureWarning(String message) {

warning(FutureWarning, message);

}

public static PyObject ImportWarning;

public static void ImportWarning(String message) {

warning(ImportWarning, message);

}

public static PyObject UnicodeWarning;

public static void UnicodeWarning(String message) {

warning(UnicodeWarning, message);

}

public static PyObject BytesWarning;

public static void BytesWarning(String message) {

warning(BytesWarning, message);

}

public static void warnPy3k(String message) {

warnPy3k(message, 1);

}

public static void warnPy3k(String message, int stacklevel) {

if (Options.py3k_warning) {

warning(DeprecationWarning, message, stacklevel);

}

}

private static PyObject warnings_mod;

private static PyObject importWarnings() {

if (warnings_mod != null) {

return warnings_mod;

}

PyObject mod;

try {

mod = __builtin__.__import__("warnings");

} catch (PyException e) {

if (e.match(ImportError)) {

return null;

}

throw e;

}

warnings_mod = mod;

return mod;

}

private static String warn_hcategory(PyObject category) {

PyObject name = category.__findattr__("__name__");

if (name != null) {

return "[" + name + "]";

}

return "[warning]";

}

public static void warning(PyObject category, String message) {

warning(category, message, 1);

}

public static void warning(PyObject category, String message, int stacklevel) {

PyObject func = null;

PyObject mod = importWarnings();

if (mod != null) {

func = mod.__getattr__("warn");

}

if (func == null) {

System.err.println(warn_hcategory(category) + ": " + message);

return;

} else {

func.__call__(Py.newString(message), category, Py.newInteger(stacklevel));

}

}

public static void warning(PyObject category, String message,

String filename, int lineno, String module,

PyObject registry) {

PyObject func = null;

PyObject mod = importWarnings();

if (mod != null) {

func = mod.__getattr__("warn_explicit");

}

if (func == null) {

System.err.println(filename + ":" + lineno + ":" +

warn_hcategory(category) + ": " + message);

return;

} else {

func.__call__(new PyObject[]{

Py.newString(message), category,

Py.newString(filename), Py.newInteger(lineno),

(module == null) ? Py.None : Py.newString(module),

registry

}, Py.NoKeywords);

}

}

public static PyObject JavaError;

public static PyException JavaError(Throwable t) {

if (t instanceof PyException) {

return (PyException) t;

} else if (t instanceof InvocationTargetException) {

return JavaError(((InvocationTargetException) t).getTargetException());

} else if (t instanceof StackOverflowError) {

return Py.RuntimeError("maximum recursion depth exceeded (Java StackOverflowError)");

} else if (t instanceof OutOfMemoryError) {

memory_error((OutOfMemoryError) t);

} else if (t instanceof UserInterruptException) {

return Py.KeyboardInterrupt("");

}

PyObject exc = PyJavaType.wrapJavaObject(t);

PyException pyex = new PyException(exc.getType(), exc);

// Set the cause to the original throwable to preserve

// the exception chain.

pyex.initCause(t);

return pyex;

}

private Py() {

}

/**

@SuppressWarnings("unchecked")

public static <T> T tojava(PyObject o, Class<T> c) {

Object obj = o.__tojava__(c);

if (obj == Py.NoConversion) {

throw Py.TypeError("can't convert " + o.__repr__() + " to " +

c.getName());

}

return (T)obj;

}

// ??pending: was @deprecated but is actually used by proxie code.

// Can get rid of it?

public static Object tojava(PyObject o, String s) {

Class<?> c = findClass(s);

if (c == null) {

throw Py.TypeError("can't convert to: " + s);

}

return tojava(o, c); // prev:Class.forName

}

/* Helper functions for PyProxy's */

/* Convenience methods to create new constants without using "new" */

private final static PyInteger[] integerCache = new PyInteger[1000];

static {

for (int j = -100; j < 900; j++) {

integerCache[j + 100] = new PyInteger(j);

}

}

public static final PyInteger newInteger(int i) {

if (i >= -100 && i < 900) {

return integerCache[i + 100];

} else {

return new PyInteger(i);

}

}

public static PyObject newInteger(long i) {

if (i < Integer.MIN_VALUE || i > Integer.MAX_VALUE) {

return new PyLong(i);

} else {

return newInteger((int) i);

}

}

public static PyLong newLong(String s) {

return new PyLong(s);

}

public static PyLong newLong(java.math.BigInteger i) {

return new PyLong(i);

}

public static PyLong newLong(int i) {

return new PyLong(i);

}

public static PyLong newLong(long l) {

return new PyLong(l);

}

public static PyComplex newImaginary(double v) {

return new PyComplex(0, v);

}

public static PyFloat newFloat(float v) {

return new PyFloat((double) v);

}

public static PyFloat newFloat(double v) {

return new PyFloat(v);

}

/**

public static PyString newString(char c) {

return makeCharacter(c);

}

/**

static PyString newString(String s, boolean promise) {

int n = s.length();

if (n > 1) {

return new PyString(s, promise);

} else if (n == 1) {

return makeCharacter(s.charAt(0));

} else {

return Py.EmptyString;

}

}

/**

public static PyString newString(String s) {

return newString(s, false);

}

/**

static PyString newBytes(String s) {

return newString(s, true);

}

/**

public static PyString newStringOrUnicode(String s) {

return newStringOrUnicode(Py.EmptyString, s);

}

/**

public static PyString newStringOrUnicode(PyObject precedent, String s) {

if (!(precedent instanceof PyUnicode) && PyString.charsFitWidth(s, 7)) {

return Py.newBytes(s);

} else {

return Py.newUnicode(s);

}

}

public static PyString newStringUTF8(String s) {

if (PyString.charsFitWidth(s, 7)) {

// ascii of course is a subset of UTF-8

return Py.newBytes(s);

} else {

return Py.newBytes(codecs.PyUnicode_EncodeUTF8(s, null));

}

}

/**

public static String fileSystemDecode(PyString filename) {

String s = filename.getString();

if (filename instanceof PyUnicode || PyString.charsFitWidth(s, 7)) {

// Already decoded or bytes usable as ASCII

return s;

} else {

// It's bytes, so must decode properly

assert "utf-8".equals(PySystemState.FILE_SYSTEM_ENCODING.toString());

return codecs.PyUnicode_DecodeUTF8(s, null);

}

}

/**

public static String fileSystemDecode(PyObject filename) {

if (filename instanceof PyString) {

return fileSystemDecode((PyString)filename);

} else {

throw Py.TypeError(String.format("coercing to Unicode: need string, %s type found",

filename.getType().fastGetName()));

}

}

/**

public static PyString fileSystemEncode(String filename) {

if (PyString.charsFitWidth(filename, 7)) {

// Just wrap it as US-ASCII is a subset of the file system encoding

return Py.newBytes(filename);

} else {

// It's non just US-ASCII, so must encode properly

assert "utf-8".equals(PySystemState.FILE_SYSTEM_ENCODING.toString());

return Py.newBytes(codecs.PyUnicode_EncodeUTF8(filename, null));

}

}

/**

public static PyString fileSystemEncode(PyString filename) {

return (filename instanceof PyUnicode) ? fileSystemEncode(filename.getString()) : filename;

}

/**

private static List<String> fileSystemDecode(PyList path) {

List<String> list = new ArrayList<>(path.__len__());

for (PyObject filename : path.getList()) {

list.add(fileSystemDecode(filename));

}

return list;

}

/**

private static PyObject getEnvironment() {

PyObject os = imp.importName("os", true);

PyObject environ = os.__getattr__("environ");

return environ;

}

/** The same as {@code getenv(name, null)}. See {@link #getenv(PyString, PyString)}. */

public static PyString getenv(PyString name) {

return getenv(name, null);

}

/**

public static PyString getenv(PyString name, PyString defaultValue) {

try {

PyObject value = getEnvironment().__finditem__(name);

if (value == null) {

return defaultValue;

} else {

return value.__str__();

}

} catch (PyException e) {

// Something is fishy about os.environ, so the name is not defined.

return defaultValue;

}

}

/** The same as {@code getenv(name, null)}. See {@link #getenv(String, String)}. */

public static String getenv(String name) {

return getenv(name, null);

}

/**

public static String getenv(String name, String defaultValue) {

PyString value = getenv(newUnicode(name), null);

if (value == null) {

return defaultValue;

} else {

// Environment variables are FS-encoded byte strings

return fileSystemDecode(value);

}

}

public static PyStringMap newStringMap() {

return new PyStringMap();

}

/**

public static PyUnicode newUnicode(char c) {

return PyUnicode.from(c);

}

/**

public static PyUnicode newUnicode(String s) {

return PyUnicode.fromString(s, false);

}

public static PyUnicode newUnicode(String s, boolean isBasic) {

return PyUnicode.fromString(s, isBasic);

}

public static PyBoolean newBoolean(boolean t) {

return t ? Py.True : Py.False;

}

public static PyObject newDate(Date date) {

if (date == null) {

return Py.None;

}

PyObject datetimeModule = __builtin__.__import__("datetime");

PyObject dateClass = datetimeModule.__getattr__("date");

Calendar cal = Calendar.getInstance();

cal.setTime(date);

return dateClass.__call__(newInteger(cal.get(Calendar.YEAR)),

newInteger(cal.get(Calendar.MONTH) + 1),

newInteger(cal.get(Calendar.DAY_OF_MONTH)));

}

public static PyObject newTime(Time time) {

if (time == null) {

return Py.None;

}

PyObject datetimeModule = __builtin__.__import__("datetime");

PyObject timeClass = datetimeModule.__getattr__("time");

Calendar cal = Calendar.getInstance();

cal.setTime(time);

return timeClass.__call__(newInteger(cal.get(Calendar.HOUR_OF_DAY)),

newInteger(cal.get(Calendar.MINUTE)),

newInteger(cal.get(Calendar.SECOND)),

newInteger(cal.get(Calendar.MILLISECOND) *

1000));

}

public static PyObject newDatetime(Timestamp timestamp) {

if (timestamp == null) {

return Py.None;

}

PyObject datetimeModule = __builtin__.__import__("datetime");

PyObject datetimeClass = datetimeModule.__getattr__("datetime");

Calendar cal = Calendar.getInstance();

cal.setTime(timestamp);

return datetimeClass.__call__(new PyObject[] {

newInteger(cal.get(Calendar.YEAR)),

newInteger(cal.get(Calendar.MONTH) + 1),

newInteger(cal.get(Calendar.DAY_OF_MONTH)),

newInteger(cal.get(Calendar.HOUR_OF_DAY)),

newInteger(cal.get(Calendar.MINUTE)),

newInteger(cal.get(Calendar.SECOND)),

newInteger(timestamp.getNanos() / 1000)});

}

public static PyObject newDecimal(String decimal) {

if (decimal == null) {

return Py.None;

}

PyObject decimalModule = __builtin__.__import__("decimal");

PyObject decimalClass = decimalModule.__getattr__("Decimal");

return decimalClass.__call__(newString(decimal));

}

public static PyCode newCode(int argcount, String varnames[],

String filename, String name,

boolean args, boolean keywords,

PyFunctionTable funcs, int func_id,

String[] cellvars, String[] freevars,

int npurecell, int moreflags) {

return new PyTableCode(argcount, varnames,

filename, name, 0, args, keywords, funcs,

func_id, cellvars, freevars, npurecell,

moreflags);

}

public static PyCode newCode(int argcount, String varnames[],

String filename, String name,

int firstlineno,

boolean args, boolean keywords,