private PyTuple makeTuple() { PyObject items[] = new PyObject[num_pools]; for (int i = 0; i < num_pools; i++) { items[i] = pools[i].__getitem__(indices[i]); } return new PyTuple(items); }
static PyTuple makeIndexedTuple(PyTuple pool, int indices[], int end) { PyObject items[] = new PyObject[end]; for (int i = 0; i < end; i++) { items[i] = pool.__getitem__(indices[i]); } return new PyTuple(items); } }
@Override public Map<String, Parameter<?>> getOutputs(ScriptEngine engine) throws ScriptException { PyDictionary outputs = (PyDictionary) process(engine).__getattr__("outputs"); Map<String, Parameter<?>> map = new TreeMap<String, Parameter<?>>(); for (String name : (List<String>) outputs.keys()) { PyTuple output = (PyTuple) outputs.get(name); Object type = output.__getitem__(0); Object desc = output.__getitem__(1); // map every key in the optional dictionary as parameter metadata entry Map<String, Object> metadata = null; if (output.size() == 3) { PyDictionary meta = (PyDictionary) output.get(2); if (meta != null && !meta.isEmpty()) { metadata = new HashMap<String, Object>(); for (Object key : meta.keySet()) { metadata.put((String) key, meta.get(key)); } } } map.put(name, parameter(name, type, 1, 1, desc, null, metadata)); } return map; }
private static int item(PyTuple tup, int i) { int val = tup.__getitem__(i).asInt(); boolean valid = true; switch (i) {
public PyObject __getitem__(PyObject key) { // Same as __finditem__, without swallowing LookupErrors. This allows // __getitem__ implementations written in Python to raise custom // exceptions (such as subclasses of KeyError). // // We are forced to duplicate the code, instead of defining __finditem__ // in terms of __getitem__. That's because PyObject defines __getitem__ // in terms of __finditem__. Therefore, we would end with an infinite // loop when self_type.lookup("__getitem__") returns null: // // __getitem__ -> super.__getitem__ -> __finditem__ -> __getitem__ // // By duplicating the (short) lookup and call code, we are safe, because // the call chains will be: // // __finditem__ -> super.__finditem__ // // __getitem__ -> super.__getitem__ -> __finditem__ -> super.__finditem__ PyType self_type=getType(); PyObject impl=self_type.lookup("__getitem__"); if (impl!=null) return impl.__get__(this,self_type).__call__(key); return super.__getitem__(key); }
parameter( arg, input.__getitem__(0), min, max, input.__getitem__(1), defaultValue, metadata);
public static PyObject load_module(String name, PyObject file, PyObject filename, PyTuple data) { PyObject mod = Py.None; PySystemState sys = Py.getSystemState(); int type = data.__getitem__(2).asInt(); while(mod == Py.None) { String compiledName;
&& (locals == null || locals.equals(None)) && (len >= 2 && len <= 3)) { o = tuple.__getitem__(0); globals = tuple.__getitem__(1); if (len == 3) { locals = tuple.__getitem__(2);
decoder = lookup(encoding).__getitem__(1); } catch (PyException ex) { if (ex.match(Py.LookupError)) {
encoder = lookup(encoding).__getitem__(0); } catch (PyException ex) { if (ex.match(Py.LookupError)) {
write_int(n); for (int i = 0; i < n; i++) { write_object(t.__getitem__(i), depth + 1); for (PyObject item : dict.iteritems().asIterable()) { PyTuple pair = (PyTuple) item; write_object(pair.__getitem__(0), depth + 1); write_object(pair.__getitem__(1), depth + 1);