Copy (efficiently) a numeric numpy array into a jvm map containing keys "datatype", "shape", and a jvm array "data" in flattened row-major form.

Call a clojure IFn object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of clojure.lang.IFn and calling invoke directly.

Call a python callable with keyword arguments. Note that you don't need this pathway to call python methods if you do not need keyword arguments; if the python object is callable then it will implement clojure.lang.IFn and you can use invoke.

Copy data from a jvm container into a numpy array or back. This allows you to use a fixed preallocated set of numpy (and potentially jvm arrays) to transfer data back and forth efficiently. The most efficient transfer will be from a java primitive array that matches the numeric type of the numpy array. Also note the element count of the numpy array and the jvm array must match.

Note this copies from the first argument to the second argument -- this is reverse the normal memcpy argument order!!. Returns the destination (to) argument.

Not this does not work with array-of-arrays. It will work with, for instance, a numpy matrix of shape 2, 2 and an double array of length 4.

Copy a python object such as a dict or a list into a comparable JVM object.

Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.

Create a numpy array from a tuple of string datatype, shape and data.

• datatype - One of "int8" "uint8" "int16" "uint16" "int32" "uint32" "int64" "uint64" "float32" "float64".
• shape - integer array of dimension e.g. [2,3].
• data - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.

This does work with array-of-array structures assuming the shape is correct but those will be slower than a single primitive array and a shape.

Get a python attribute. This corresponds to the python '.' operator.

Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.

Lock the gil returning an AutoCloseable that will unlock the gil upon close.

Example:

  try (AutoCloseable locker = java_api.GILLocker()) {
    ... Do your python stuff.
  }

Returns true if this python object has this attribute.

Return true if this pyobj has this item

Import a python module. Module entries can be accessed via getAttr.

See options for libpython-clj2.python/initialize!. Note that the keyword option arguments can be provided by using strings so :library-path becomes the key "library-path". Also note that there is still a GIL underlying all of the further operations so java should access python via single-threaded pathways.

Initialize python when this library is being called from a python program. In that case the system will look for the python symbols in the current executable. See the embedded topic

Attempt to lock the gil. This is safe to call in a reentrant manner. Returns a long representing the gil state that must be passed into unlockGIL.

See documentation for pyGILState_Ensure.

Note that the API will do this for you but locking the GIL before doing a string of operations is faster than having each operation lock the GIL individually.

Given a normal python callable, make a fastcallable object that needs to be closed. This should be seen as a callsite optimization for repeatedly calling a specific python function in a tight loop with positional arguments. It is not intended to be used in a context where you will then pass this object around as this is not a reentrant optimization.

  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
     tightloop: {
       java_api.call(fastcaller, arg1, arg2);
     }
  }

Run a string returning the result of the last expression. Strings are compiled and live for the life of the interpreter. This is the equivalent to the python exec all.

The global context is returned as a java map.

This function expects the GIL to be locked - it will not lock/unlock it for you.

Example:

   Map globals = java_api.runStringAsFile("def calcSpread(bid,ask):
	return bid-ask

");
   Object spreadFn = globals.get("calcSpread");
   java_api.call(spreadFn, 1, 2); // Returns -1

Run a string returning the result of the last expression. Strings are compiled and live for the life of the interpreter. This is the equivalent to the python eval call.

This function expects the GIL to be locked - it will not lock/unlock it for you.

Example:

  java_api.setGlobal("bid", 1);
  java_api.setGlobal("ask", 2);
  java_api.runStringAsInput("bid-ask"); //Returns -1

Set an attribute on a python object. This corresponds to the __setattr python call.

Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.

In addition to numbers and strings, this method can take an implementation of clojure.lang.IFn that will be converted to a python callable, arrays and lists will be converted to python lists. If you would like numpy arrays use -createArray.

Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.