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

->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 simple string returning boolean 1 or 0. 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]})

If you don't know what you are doing, this will sink you. See documentation for run-simple-string.

set-attr! clj

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

set-item! clj

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