@Override public String toString() { return "<" + get_opname().__getitem__(Py.newInteger(b_type)) + "," + b_handler + "," + b_level + ">"; } }
@Override public PyObject __iternext__() { PyObject result = null; _index++; if (_index < size()) { result = _keys.__getitem__(_index); } return result; }
public PyObject __getslice__( PyObject s_start, PyObject s_stop, PyObject s_step) { PySlice s = new PySlice(s_start, s_stop, s_step); return __getitem__(s); }
@ExposedMethod public PyObject dictproxy___getitem__(PyObject key) { return dict.__getitem__(key); }
/** * Check thet the error handler returned a tuple * <code>(replacement_unicode, resume_index)</code>. * * @param errors name of the error policy * @param replacementSpec from error handler */ private static void checkErrorHandlerReturn(String errors, PyObject replacementSpec) { if (!(replacementSpec instanceof PyTuple) || replacementSpec.__len__() != 2 || !(replacementSpec.__getitem__(0) instanceof PyBaseString) || !(replacementSpec.__getitem__(1) instanceof PyInteger)) { throw new PyException(Py.TypeError, "error_handler " + errors + " must return a tuple of (replacement, new position)"); } }
private void print_debug(int count, int next_instr, int line, int opcode, int oparg, PyStack stack, PyFrame f) { if (debug) { System.err.println(co_name + " " + line + ":" + count + "," + f.f_lasti + "> " + get_opname().__getitem__(Py.newInteger(opcode)) + (opcode >= Opcode.HAVE_ARGUMENT ? " " + oparg : "") + ", stack: " + stack.toString() + ", blocks: " + stringify_blocks(f)); } }
/** * Merge another PyObject via its keys() method * * @param other a PyObject with a keys() method * @param keys the result of other's keys() method */ private void mergeFromKeys(PyObject other, PyObject keys) { for (PyObject key : keys.asIterable()) { __setitem__(key, other.__getitem__(key)); } }
/** * Merge another PyObject via its keys() method * * @param other a PyObject with a keys() method * @param keys the result of other's keys() method */ private void mergeFromKeys(PyObject other, PyObject keys) { for (PyObject key : keys.asIterable()) { dict___setitem__(key, other.__getitem__(key)); } }
@ExposedMethod(doc = BuiltinDocs.BaseException___getitem___doc) final PyObject BaseException___getitem__(PyObject index) { Py.warnPy3k("__getitem__ not supported for exception classes in 3.x; use args " + "attribute"); return args.__getitem__(index); }
@ExposedMethod final PyObject itemgetter___call__(PyObject[] args, String[] keywords) { ArgParser ap = new ArgParser("itemgetter", args, Py.NoKeywords, "obj"); PyObject obj = ap.getPyObject(0); if (items.length == 1) { return obj.__getitem__(items[0]); } PyObject[] result = new PyObject[items.length]; int i = 0; for (PyObject item : items) { result[i++] = obj.__getitem__(item); } return new PyTuple(result); }
public String[] getEnv() { PyObject items = imp.load("os").__getattr__("environ").invoke("items"); String[] env = new String[items.__len__()]; int i = 0; for (PyObject item : items.asIterable()) { env[i++] = String.format("%s=%s", item.__getitem__(0), item.__getitem__(1)); } return env; }
private void mergeFromKeys(PyObject other, PyObject keys) { for (PyObject key : keys.asIterable()) { jmap.put(Py.tojava(key, Object.class), Py.tojava(other.__getitem__(key), Object.class)); } }
/** * Fetch the next row of a query result set, returning a single sequence, * or None when no more data is available. * <p/> * An Error (or subclass) exception is raised if the previous call to * executeXXX() did not produce any result set or no call was issued yet. * * @return a single sequence from the result set, or None when no more data is available */ public PyObject fetchone() { PyObject sequence = fetchmany(1); if (sequence.__len__() == 1) { return sequence.__getitem__(0); } else { return Py.None; } }
public static PyString _PickleError__str__(PyObject self, PyObject[] args, String[] kwargs) { PyObject selfArgs = self.__getattr__("args"); if (selfArgs.__len__() > 0 && selfArgs.__getitem__(0).__len__() > 0) { return selfArgs.__getitem__(0).__str__(); } else { return new PyString("(what)"); } }
/** * Handle the data callback and write the row out. */ public void row(PyObject row) { String[] values = new String[row.__len__()]; if (this.header) { for (int i = 0; i < row.__len__(); i++) { values[i] = this.convert(Py.newInteger(i), row.__getitem__(i)); } } else { for (int i = 0; i < row.__len__(); i++) { values[i] = row.__getitem__(i).__getitem__(0).toString(); } this.header = true; } this.println(values); }
public static PyObject KeyError__str__(PyObject self, PyObject[] args, String[] kwargs) { PyBaseException selfBase = (PyBaseException)self; // If args is a tuple of exactly one item, apply repr to args[0]. // This is done so that e.g. the exception raised by {}[''] prints // KeyError: '' // rather than the confusing // KeyError // alone. The downside is that if KeyError is raised with an explanatory // string, that string will be displayed in quotes. Too bad. if (selfBase.args.__len__() == 1) { return selfBase.args.__getitem__(0).__repr__(); } return PyBaseException.TYPE.invoke("__str__", self, args, kwargs); }
public static void utime(PyObject path, PyObject times) { long[] atimeval; long[] mtimeval; if (times == Py.None) { atimeval = mtimeval = null; } else if (times instanceof PyTuple && times.__len__() == 2) { atimeval = extractTimeval(times.__getitem__(0)); mtimeval = extractTimeval(times.__getitem__(1)); } else { throw Py.TypeError("utime() arg 2 must be a tuple (atime, mtime)"); } if (posix.utimes(absolutePath(path).toString(), atimeval, mtimeval) < 0) { throw errorFromErrno(path); } }
@ExposedMethod(doc = BuiltinDocs.BaseException___str___doc) final PyString BaseException___str__() { switch (args.__len__()) { case 0: return Py.EmptyString; case 1: return args.__getitem__(0).__str__(); default: return args.__str__(); } }
protected void mergeClassDict(PyDictionary accum, PyObject aClass) { // Merge in the type's dict (if any) aClass.mergeDictAttr(accum, "__dict__"); // Recursively merge in the base types' (if any) dicts PyObject bases = aClass.__findattr__("__bases__"); if (bases == null) { return; } // We have no guarantee that bases is a real tuple int len = bases.__len__(); for (int i = 0; i < len; i++) { mergeClassDict(accum, bases.__getitem__(i)); } }
public static PyString _UnpickleableError__str__(PyObject self, PyObject[] args, String[] kwargs) { PyObject selfArgs = self.__getattr__("args"); PyObject a = selfArgs.__len__() > 0 ? selfArgs.__getitem__(0) : new PyString("(what)"); return new PyString("Cannot pickle %s objects").__mod__(a).__str__(); }