Work on probe

Author: Thrameos

native/jpype_module/src/main/java/org/jpype/bridge/Backend.java

@@ -21,6 +21,8 @@
 import python.lang.PyComplex;
 import python.lang.PyDict;
 import python.lang.PyEnumerate;
+import python.lang.PyFloat;
+import python.lang.PyFrozenSet;
 import python.lang.PyList;
 import python.lang.PyMemoryView;
 import python.lang.PyObject;
@@ -34,6 +36,7 @@
 import python.protocol.PyCallable;
 import python.protocol.PyMapping;
 import python.protocol.PyIter;
+import python.protocol.PyIterable;
 
 /**
  * Backend for all Python entry points.
@@ -56,19 +59,19 @@ public interface Backend
 
   PyByteArray bytearray(Object obj);
 
-  PyByteArray bytearray_fromhex(CharSequence str);
+  PyByteArray bytearrayFromHex(CharSequence str);
 
   PyBytes bytes(Object obj);
 
-  PyBytes bytes_fromhex(CharSequence str);
+  PyBytes bytesFromHex(CharSequence str);
 
   PyObject call(PyCallable obj, PyTuple args, PyDict kwargs);
 
   PyComplex complex(double r, double i);
 
   void delattr(Object obj, CharSequence str);
 
-  public boolean delindex(PyList aThis, int indexOf);
+  boolean delindex(PyList aThis, int indexOf);
 
   PyDict dict();
 
@@ -98,7 +101,7 @@ public interface Backend
 
   PyMemoryView memoryview(Object obj);
 
-  PyDict newDict(Map<Object, Object> map);
+  PyDict newDict(Map map);
 
   public PySet newSet(Iterable c);
 
@@ -184,4 +187,32 @@ public interface Backend
 //staticmethod()
 //super()
 
+  public PyObject sequenceGetItem(PyObject obj);
+
+  public PyFrozenSet newFrozenSet(Iterable c);
+
+  public PyComplex newComplex(double real, double imag);
+
+  public PyByteArray newByteArray();
+
+  public PyByteArray newByteArray(int i);
+
+  public PyByteArray newByteArray(Iterable iter);
+
+  public PyEnumerate newEnumerate(Iterable iterable);
+
+  public PyByteArray newByteArray(PyBytes bytes);
+
+  public PyBytes newBytes(int length);
+
+  public PyByteArray newBytes(Iterable<PyObject> iter);
+
+  public PyByteArray newBytes(PyByteArray bytes);
+
+  public PyFloat newInt(long value);
+
+  public PyFloat newDouble(double value);
+
+  public PyFloat newZip(PyIterable[] items);
+
 }

native/jpype_module/src/main/java/org/jpype/bridge/BuiltIn.java

@@ -28,6 +28,7 @@
 import python.lang.PyType;
 import python.lang.PyZip;
 import python.protocol.PyCallable;
+import python.protocol.PyIndex;
 import python.protocol.PyMapping;
 import python.protocol.PyIter;
 
@@ -64,7 +65,7 @@ public static void delattr(PyObject obj, CharSequence key)
   {
     Interpreter.backend.delattr(obj, key);
   }
-
+ 
   public static PyObject next(PyIter iter, PyObject stop)
   {
     return Interpreter.backend.next(iter, stop);
@@ -181,6 +182,10 @@ public static PyString repr(Object obj)
 
   public static void setattr(PyObject obj, CharSequence key, Object value)
   {
+    // FIXME we may want special handling for String and Boxed types to 
+    // ensure the type that appears is a Python one rather than a 
+    // Java one especially on setattr in which the object is to be 
+    // held in Python.
     Interpreter.backend.setattr(obj, key, value);
   }
 
@@ -268,4 +273,14 @@ public static PyZip zip(PyObject... objects)
     return Interpreter.backend.zip(objects);
   }
 
+  public static PyInt $int(long value)
+  {
+    return Interpreter.backend.newInt(value);
+  }
+  
+  public static PyFloat $float(long value)
+  {
+    return Interpreter.backend.newFloat(value);
+  }
+
 }

native/jpype_module/src/main/java/python/lang/PyByteArray.java

@@ -23,6 +23,30 @@
  */
 public interface PyByteArray extends PyObject
 {
+  /** 
+   * Create a new ByteArray with a fixed length.
+   * 
+   * @param length
+   * @return 
+   */
+  static PyByteArray of(int length)
+  {
+     return Interpreter.getBackend().newByteArray(length);
+  }
+  
+  static PyByteArray of(Iterable<PyObject> iter )
+  {
+     return Interpreter.getBackend().newByteArray(iter);
+  }
+
+  static PyByteArray of(PyBytes bytes)
+  {
+     return Interpreter.getBackend().newByteArray(bytes);
+  }
+  
+ 
+  // FIXME also needs ByteLike (Bytes, ByteArray, String)
+  
 
   static PyType type()
   {
@@ -31,7 +55,7 @@ static PyType type()
 
   static PyByteArray fromHex(CharSequence str)
   {
-    return Interpreter.getBackend().bytearray_fromhex(str);
+    return Interpreter.getBackend().bytearrayFromHex(str);
   }
 
   PyObject decode(PyObject encoding, PyObject delete);

native/jpype_module/src/main/java/python/lang/PyBytes.java

@@ -23,15 +23,35 @@
  */
 public interface PyBytes extends PyObject
 {
+  /** 
+   * Create a new ByteArray with a fixed length.
+   * 
+   * @param length
+   * @return 
+   */
+  static PyBytes of(int length)
+  {
+     return Interpreter.getBackend().newBytes(length);
+  }
+  
+  static PyByteArray of(Iterable<PyObject> iter )
+  {
+     return Interpreter.getBackend().newBytes(iter);
+  }
 
+  static PyByteArray of(PyByteArray bytes)
+  {
+     return Interpreter.getBackend().newBytes(bytes);
+  }
+  
   static PyType type()
   {
     return (PyType) BuiltIn.eval("bytes", null, null);
   }
 
   static PyBytes fromHex(CharSequence str)
   {
-    return Interpreter.getBackend().bytes_fromhex(str);
+    return Interpreter.getBackend().bytesFromHex(str);
   }
 
   PyObject decode(PyObject encoding, PyObject delete);

native/jpype_module/src/main/java/python/lang/PyComplex.java

@@ -16,14 +16,19 @@
 package python.lang;
 
 import org.jpype.bridge.BuiltIn;
+import org.jpype.bridge.Interpreter;
 import python.protocol.PyNumber;
 
 /**
  * Java front end for concrete Python complex.
  */
-public interface PyComplex extends PyNumber, PyObject
+public interface PyComplex extends PyObject, PyNumber
 {
-
+  static PyComplex of(double real, double imag)
+  {
+    return Interpreter.getBackend().newComplex(real, imag);
+  }
+          
   static PyType type()
   {
     return (PyType) BuiltIn.eval("complex", null, null);

native/jpype_module/src/main/java/python/lang/PyDict.java

@@ -15,7 +15,9 @@
  */
 package python.lang;
 
+import java.util.Map;
 import org.jpype.bridge.BuiltIn;
+import org.jpype.bridge.Interpreter;
 import python.protocol.PyMapping;
 
 /**
@@ -25,6 +27,10 @@
  */
 public interface PyDict extends PyObject, PyMapping
 {
+  static PyDict of(Map<Object, PyObject> map)
+  {
+    return Interpreter.getBackend().newDict(map);
+  }
 
   static PyType type()
   {

native/jpype_module/src/main/java/python/lang/PyEnumerate.java

@@ -17,13 +17,20 @@
 
 import python.protocol.PyGenerator;
 import org.jpype.bridge.BuiltIn;
+import org.jpype.bridge.Interpreter;
+import python.protocol.PyIterable;
 
 /**
  * Java front end for concrete Python enumerate.
  */
 public interface PyEnumerate extends PyGenerator
 {
 
+  static PyEnumerate of(Iterable<PyObject> iterable)
+  {
+    return Interpreter.getBackend().newEnumerate(iterable);
+  }
+
   static PyType type()
   {
     return (PyType) BuiltIn.eval("enumerate", null, null);

native/jpype_module/src/main/java/python/lang/PyFloat.java

@@ -0,0 +1,37 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *  use this file except in compliance with the License. You may obtain a copy of
+ *  the License at
+ * 
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  License for the specific language governing permissions and limitations under
+ *  the License.
+ * 
+ *  See NOTICE file for details.
+ */
+package python.lang;
+
+import org.jpype.bridge.BuiltIn;
+import org.jpype.bridge.Interpreter;
+import python.protocol.PyNumber;
+
+/**
+ *
+ */
+public interface PyFloat extends PyObject, PyNumber 
+{
+    static PyFloat of(double value)
+  {
+     return Interpreter.getBackend().newDouble(value);
+  }
+  
+  static PyType type()
+  {
+    return (PyType) BuiltIn.eval("float", null, null);
+  }
+
+}