libpython-clj.python — cnuernber/libpython-clj 1.0

->jvm clj

(->jvm item & [options])

Copy an object into the jvm (if it wasn't there already.)

->numpy clj

(->numpy item & [options])

->py-dict clj

(->py-dict item)

->py-float clj

(->py-float item)

->py-fn clj

(->py-fn fn-obj)

(->py-fn fn-obj
         {:keys [method-name documentation py-self]
          :or {method-name "unnamed_function" documentation "not documented"}})

Create a python callback from a clojure fn. If clojure fn, then tuple arguments are used. If keyword arguments are desired, the pass in something derived from: libpython-clj.jna.CFunction$KeyWordFunction. If a pure fn is passed in, arguments are marshalled from python if possible and then to-python in the case of successful execution. An exception will set the error indicator.

->py-list clj

(->py-list item-seq)

->py-long clj

(->py-long item)

->py-string clj

(->py-string item)

->py-tuple clj

(->py-tuple item-seq)

->python clj

(->python item & [options])

Completely convert a jvm object to a python copy.

add-module clj

(add-module modname)

Add a python module. Returns a bridge

as-jvm clj

(as-jvm item & [options])

Bridge a python object into the jvm. Attempts to build a jvm bridge that 'hides' the python type. This bridge is lazy and noncaching so use it wisely; it may be better to just copy the type once into the JVM. Bridging is recursive so any subtypes are also bridged if possible or represented by a hashmap of {:type :value} if not.

as-list clj

(as-list item)

Return a List implementation using getitem, setitem.

as-map clj

(as-map item)

Return a Map implementation using getitem, setitem. Note that it may be incomplete especially if the object has no 'keys' attribute.

as-numpy clj

(as-numpy item & [options])

as-python clj

(as-python item & [options])

Bridge a jvm object into python

as-tensor clj

(as-tensor item)

Return a tech.v2.tensor object from the item that shares the data backing store.

att-type-map clj

(att-type-map item)

Get hashmap of att name to keyword datatype.

call clj

(call callable & args)

call-attr clj

(call-attr item att-name & args)

Call an object attribute

call-attr-kw clj

(call-attr-kw item att-name arglist kw-map)

call-kw clj

(call-kw callable arglist kw-args)

callable? clj

(callable? item)

dir clj

(dir item)

Get sorted list of all attribute names.

finalize! clj

(finalize!)

get-attr clj

(get-attr item item-name)

get-item clj

(get-item item item-name)

has-attr? clj

(has-attr? item item-name)

has-item? clj

(has-item? item item-name)

import-module clj

(import-module modname)

Import a python module. Returns a bridge

initialize! clj

(initialize! & {:keys [program-name no-io-redirect?]})

len clj

(len item)

libpython-clj-module-name clj

module-dict clj

(module-dict module)

Get the module dictionary. Returns bridge.

python-type clj

(python-type item)

run-simple-string clj

(run-simple-string program & {:keys [globals locals]})

Run a string expression returning a map of {:globals :locals :result}. This uses the global main dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.

Note this will never return the result of the expression: https://mail.python.org/pipermail/python-list/1999-April/018011.html

Globals, locals may be provided but are not necessary.

Implemented in cpython as:

PyObject *m, *d, *v; m = PyImport_AddModule("main"); if (m == NULL) return -1; d = PyModule_GetDict(m); v = PyRun_StringFlags(command, Py_file_input, d, d, flags); if (v == NULL) { PyErr_Print(); return -1; } Py_DECREF(v); return 0;

run-string clj

(run-string program & {:keys [globals locals]})

Wrapper around the python c runtime PyRun_String method. This requires you to understand what needs to be in the globals and locals dict in order for everything to work out right and for this reason we recommend run-simple-string.

set-attr! clj

(set-attr! item item-name item-value)

set-item! clj

(set-item! item item-name item-value)