libpython-clj2.java-api

:artifact "target/libpython-clj.jar"}}

:depstar-aot

{:replace-deps

{com.github.seancorfield/depstar {:mvn/version "2.0.193"}}

:ns-default hf.depstar

:exec-fn hf.depstar/jar

:exec-args {:group-id "clj-python"

:artifact-id "libpython-clj"

:version "2.004-aot"

:sync-pom true

:aot true

:compile-ns [libpython-clj2.java-api]

:jar "target/libpython-clj-aot.jar"}}

:deploy-aot

{:replace-deps {slipset/deps-deploy {:mvn/version "0.1.5"}}

:exec-fn deps-deploy.deps-deploy/deploy

:exec-args {:installer :remote

:sign-releases? true

:artifact "target/libpython-clj-aot.jar"}}

}}

(ns libpython-clj2.java-api

(:require [tech.v3.datatype :as dtype]

[tech.v3.tensor :as dtt]

[tech.v3.datatype.jvm-map :as jvm-map]

[libpython-clj2.python :as py]

[libpython-clj2.python.fn :as py-fn]

;; numpy support

[libpython-clj2.python.np-array])

(:import [java.util Map]

[java.util.function Supplier])

(:gen-class

:name libpython_clj2.java_api

:main false

:methods [#^{:static true} [initialize [java.util.Map] Object]

#^{:static true} [runString [String] java.util.Map]

#^{:static true} [inPyContext [java.util.function.Supplier] Object]

#^{:static true} [hasAttr [Object String] Boolean]

#^{:static true} [getAttr [Object String] Object]

#^{:static true} [setAttr [Object String Object] Object]

#^{:static true} [hasItem [Object Object] Boolean]

#^{:static true} [getItem [Object Object] Object]

#^{:static true} [setItem [Object Object Object] Object]

#^{:static true} [importModule [String] Object]

#^{:static true} [callKw [Object java.util.List java.util.Map] Object]

#^{:static true} [copyToPy [Object] Object]

#^{:static true} [copyToJVM [Object] Object]

#^{:static true} [createArray [String Object Object] Object]

#^{:static true} [arrayToJVM [Object] java.util.Map]]))

(set! *warn-on-reflection* true)

(defn -initialize

"See options for [[libpython-clj2.python/initialize!]]. Note that the keyword

[options]

(apply py/initialize! (->> options

(mapcat (fn [entry]

[(keyword (jvm-map/entry-key entry))

(jvm-map/entry-value entry)])))))

(defn -runString

"Run a string returning a map of two keys -\"globals\" and \"locals\" which each point to

^java.util.Map [^String code]

(->> (py/run-simple-string code)

(map (fn [[k v]]

[(name k) v]))

(into {})))

(defn -inPyContext

"Run some code in a python context where all python objects allocated within the context

[^Supplier fn]

(py/with-gil-stack-rc-context

(-> (.get fn)

(py/->jvm))))

(defn -hasAttr

"Returns true if this python object has this attribute."

[pyobj attname]

(boolean (py/has-attr? pyobj attname)))

(defn -getAttr

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

[pyobj attname]

(py/get-attr pyobj attname))

(defn -setAttr

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

[pyobj attname objval]

(py/set-attr! pyobj attname objval))

(defn -hasItem

"Return true if this pyobj has this item"

[pyobj itemName]

(boolean (py/has-item? pyobj itemName)))

(defn -getItem

[pyobj itemName]

(py/get-item pyobj itemName))

(defn -getItem

[pyobj itemName]

(py/get-item pyobj itemName))

(defn -setItem

[pyobj itemName itemVal]

(py/get-item pyobj itemName itemVal))

(defn -importModule

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

[modname]

(py/import-module modname))

(defn -callKw

"Call a python callable with keyword arguments. Note that you don't need this pathway

[pyobj pos-args kw-args]

(py/with-gil (py-fn/call-kw pyobj pos-args (->> kw-args

(map (fn [entry]

[(jvm-map/entry-key entry)

(jvm-map/entry-value entry)]))

(into {})))))

(defn -copyToPy

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

[object]

(py/->python object))

(defn -copyToJVM

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

[object]

(py/->jvm object))

(defn -createArray

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

[datatype shape data]

(-> (dtt/->tensor data :datatype (keyword datatype))

(dtt/reshape shape)

(py/->python)))

(defn -arrayToJVM

"Copy (efficiently) a numeric numpy array into a jvm map containing keys \"datatype\",

[pyobj]

(let [tens-data (py/as-jvm pyobj)]

{"datatype" (name (dtype/elemwise-datatype tens-data))

"shape" (int-array (dtype/shape tens-data))

"data" (dtype/->array tens-data)}))

"Import a python module. Module entries can be accessed via get-attr."

:int32 "c_int"

:uint32 "c_uint"

(ns libpython-clj2.java-api-test

(:require [libpython-clj2.java-api :as japi]

[tech.v3.datatype.jvm-map :as jvm-map]

[clojure.test :refer [deftest is]]))

(deftest base-japi-test

(japi/-initialize nil)

(let [rs-retval (japi/-runString "data = 5")

globals (get rs-retval "globals")]

(is (= 5 (get globals "data"))))

(let [np (japi/-importModule "numpy")

ones-fn (japi/-getAttr np "ones")

;;also works with int-array

base-data (ones-fn (java.util.ArrayList. [2 3]))

jvm-data (japi/-arrayToJVM base-data)]

(is (= "float64" (get jvm-data "datatype")))

(is (= (vec (repeat 6 1.0))

(vec (get jvm-data "data"))))

(let [base-data (japi/-callKw ones-fn [[2 3]] {"dtype" "int32"})

jvm-data (japi/-arrayToJVM base-data)]

(is (= "int32" (get jvm-data "datatype")))

(is (= (vec (repeat 6 1))

(vec (get jvm-data "data")))))))