(ns libpython-clj2.codegen

"Generate a namespace on disk for a python module or instances"

(:require [clojure.java.io :as io]

[libpython-clj2.python :as py]

[clojure.string :as s]

[clojure.tools.logging :as log])

(:import [java.nio.file Paths]

[java.io Writer]))

(defn- escape-quotes

[input-str]

(if input-str

(-> (.replace (str input-str) "\\" "\\\\")

(.replace "\"" "\\\""))

""))

(defn- get-docs

[v]

(escape-quotes (:doc v "No documentation")))

(defn- output-module-list

[^Writer writer clj-name k v]

(.write writer

(format "

(def ^{:doc \"%s\"} %s (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* \"%s\")))) "

(get-docs v)

clj-name

k)))

(defn- output-module-tuple

[^Writer writer clj-name k v]

(.write writer

(format "

(def ^{:doc \"%s\"} %s (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* \"%s\")))) "

(get-docs v)

clj-name

k)))

(defn- output-module-dict

[^Writer writer clj-name k v]

(.write writer

(format "

(def ^{:doc \"%s\"} %s (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* \"%s\")))) "

(get-docs v)

clj-name

k)))

(defn- output-module-callable

[^Writer writer clj-name k v]

(.write writer

(format "

(def ^{:doc \"%s\" :arglists '%s} %s (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* \"%s\"))))"

(get-docs v)

(:arglists v)

clj-name

k

clj-name)))

(defn- output-module-generic

[^Writer writer clj-name k v vv]

(let [output-value (cond

;;nils and boolean require no extra formatting

(or (nil? vv) (boolean? vv)) vv

;;string values should be output surrounded by double quotes

(string? vv) (format "\"%s\"" (escape-quotes vv))

;;NaN is a number and should use the proper reader macro

(and (number? vv) (Double/isNaN vv)) "##NaN"

;;Finite, non NAN numbers should be treated as literals

(and (number? vv) (Double/isFinite vv)) vv

;;Positive and negative infinity are numbers and should use the proper reader macros

(and (number? vv) (not (neg? vv)) (Double/isInfinite vv)) "##Inf"

(and (number? vv) (neg? vv) (Double/isInfinite vv)) "##-Inf"

;;Anything else should be derefed by name from Python

:else (format "(as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* \"%s\")))" k)

)]

(.write writer

(format "\n\n(def ^{:doc \"%s\"} %s %s)"

(get-docs v)

clj-name

output-value))))

(def ^:no-doc default-exclude

'[+ - * / float double int long mod byte test char short take partition require

max min identity empty mod repeat str load cast type sort conj

map range list next hash eval bytes filter compile print set format

compare reduce merge])

(def ^:private invalid-symbol-names

#{"__cached__" "__file__"})

(defn write-namespace!

"Generate a clojure namespace file from a python module or class. If python hasn't

been initialized yet this will call the default python initialization. Accessing

the generated namespace without initialization will cause an error.

Once generated this namespace is safe to be used for AOT,

Options:

* `:output-fname` - override the autogenerated file path.

* `:output-dir` - Defaults \"src\". Set the output directory. The final filename,

if `:output-fname` is not provided, is built up from `:ns-prefix and

`py-mod-or-cls`.

* `:ns-symbol` - The fully qualified namespace symbol. If not provided is built

from `:ns-prefix` and `py-mod-or-cls`.

* `:ns-prefix` - The prefix used for all python namespaces. Defaults to \"python\".

* `:symbol-name-remaps` - A list of remaps used to avoid name clashes with

clojure.core or builtin java symbols.

* `:exclude` - List of symbols used like `(:refer-clojure :exclude %s)`. You can

see the default list as `codegen/default-exclude`.

Example:

```clojure

user> (require '[libpython-clj2.codegen :as codegen])

nil

user> (codegen/write-namespace!

\"builtins\" {:symbol-name-remaps {\"AssertionError\" \"PyAssertionError\"

\"Exception\" \"PyException\"}})

:ok

user> (require '[python.builtins :as python])

nil

user> (doc python/list)

-------------------------

python.builtins/list

[[self & [args {:as kwargs}]]]

Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list.

The argument must be an iterable if specified.

nil

user> (doto (python/list)

(.add 1)

(.add 2))

[1, 2]

```"

([py-mod-or-cls {:keys [output-fname output-dir ns-symbol

ns-prefix symbol-name-remaps exclude]

:or {output-dir "src"

ns-prefix "python"

exclude default-exclude}}]

(let [metadata-fn (requiring-resolve

'libpython-clj2.metadata/datafy-module-or-class)

ns-symbol (or ns-symbol (symbol (str (when-not (s/blank? ns-prefix)

(str ns-prefix "."))

py-mod-or-cls)))]

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

(let [target (py/path->py-obj py-mod-or-cls)

target-metadata (metadata-fn target)

output-fname (or output-fname

(-> (->> (-> (str ns-symbol)

(.replace "-" "_")

(s/split #"\."))

(into-array String)

(Paths/get output-dir))

(str ".clj")))]

(log/debugf "Writing python module %s to file %s" target output-fname)

(io/make-parents output-fname)

(with-open [writer (io/writer output-fname)]

(.write writer (format "(ns %s

\"%s\"

(:require [libpython-clj2.python :as py]

[libpython-clj2.python.jvm-handle :refer [py-global-delay]]

[libpython-clj2.python.bridge-as-jvm :as as-jvm])

(:refer-clojure :exclude %s))"

(name ns-symbol)

(escape-quotes

(get target "__doc__" "No documentation provided"))

(or exclude [])))

(.write writer

(format "\n\n(defonce ^:private src-obj* (py-global-delay (py/path->py-obj \"%s\")))"

py-mod-or-cls))

(doseq [[k v] target-metadata]

(when (and (string? k)

(not= "__cached__" k)

(not= 0 (count k))

(map? v)

(py/has-attr? target k))

(let [clj-name (get symbol-name-remaps k k)]

(case (:type v)

:list (output-module-list writer clj-name k v)

:tuple (output-module-tuple writer clj-name k v)

:dict (output-module-dict writer clj-name k v)

(if (:callable? (:flags v))

(output-module-callable writer clj-name k v)

(output-module-generic writer clj-name k v

(py/get-attr target k))))))))

:ok))))

([py-mod-or-cls]

(write-namespace! py-mod-or-cls nil)))

(comment

(do

(write-namespace! "builtins"

{:symbol-name-remaps

{"AssertionError" "PyAssertionError"

"Exception" "PyException"}})

(write-namespace! "numpy")

)

)